We often face multi-company deployment challenges: an agency serves multiple clients from a single installation, with each client seeing only its own data. Or a holding company with several legal entities—shared infrastructure, isolated AI organizations. A typical situation: starting with one client is simple, but when there are 10, 50, or 100, the cost of supporting separate instances grows linearly. Our multi-tenant Paperclip deployment ensures data isolation and white-label capabilities. In this article, we present the architectural solution we've applied for over 5 years in 10+ projects. It enables centralized management of hundreds of organizations while maintaining p99 latency at 200 ms even under peak loads.
What isolation levels do we use?
Isolation is built on multiple levels. At the lower level, database-level isolation: separate PostgreSQL schemas per organization with Row-Level Security. This ensures that queries from company A's agent never return company B's data. The added latency from RLS is 1–2 ms, unnoticeable to the user. Each company's schema contains over 50 tables for agents, contexts, and logs.
Above that, namespace isolation: each agent operates in its own organization's context. LLM calls are tagged with organization_id, logs are fully separated. Resource isolation via separate task queues (Redis namespacing) and rate limits configurable per company. For high requirements, optional network isolation via Docker networks.
Compare the levels in a table:
| Isolation level | Mechanism | Latency | Configuration complexity |
|---|---|---|---|
| Database-level | PostgreSQL schemas + RLS | <2 ms | Low |
| Agent namespace | organization_id in every request | <0.5 ms | Medium |
| Resource (queues, limits) | Redis namespaces, rate limiting | ~0 ms | Medium |
| Network-level (optional) | Docker networks per organization | ~0 ms | High |
Additionally, each company can have its own RAG knowledge bases with isolated embeddings (e.g., 1536-dimensional via text-embedding-ada-002). This enables building personalized AI assistants without context crossover.
Why is multi-tenant Paperclip 3–5 times cheaper?
Infrastructure savings: one installation serves dozens of organizations. Centralized management via super-admin panel: company creation, tariff configuration, usage monitoring, and billing. Compared to traditional per-client deployments, our solution reduces time to add a company from 1–2 weeks to 1 hour. Multi-tenant Paperclip also offers better performance: p99 latency of 200 ms vs 500 ms typical for isolated instances. Kubernetes enables dynamic resource scaling as the number of organizations grows—horizontal scaling of workers. Our estimates show that multi-tenant Paperclip is 3-5 times more cost-effective than separate instances. For an agency managing 20 clients, this translates to saving approximately $10,000 per month compared to deploying separate instances. The investment starts at $4,999 for a standard setup with up to 10 companies.
Compare deployment scenarios:
| Parameter | Separate instances | Multi-tenant Paperclip |
|---|---|---|
| Number of servers | N | 1–2 |
| Time to add a company | 1–2 weeks | 1 hour |
| Monitoring complexity | High (N dashboards) | Low (single dashboard) |
| White-label capability | Requires separate config | Built-in |
Common mistakes in isolation setup
- Missing RLS: forgetting to enable it on all tables leads to data leaks. Verify with test queries using different
organization_id. - Mixing queues: using a single Redis namespace allows one company's tasks to block another's. Always isolate queues via prefixes (e.g.,
company_123:queue). - Unconfigured rate limits: during activity spikes, one organization can consume all GPU resources. Set limits on tokens per minute and parallel requests.
How we test isolation
We run automated isolation tests: launch agents on behalf of different companies and verify no data crossover. We use random queries and measure leaks—target: zero crossover. Load tests with peak traffic from 10 to 100 organizations confirm p99 latency stays under 200 ms (compared to 500 ms for non-optimized setups). For sensitive scenarios, we add audit logs to detect prompt injection—isolated namespaces prevent one company from affecting another's context.
Process
- Analysis — study the use case, number of companies, isolation requirements, and compliance. For example, a recent deployment for a holding company with 15 legal entities was completed in 4 weeks.
- Design — develop a multi-tenant database schema, define namespace and resource isolation configuration.
- Implementation — configure PostgreSQL schemas, RLS, admin panel, billing integration.
- Testing — isolation tests: verify company A's agent cannot see company B's data. Load tests under peak load.
- Deployment — deploy on your infrastructure or our cloud, train administrators.
What's included
- Documentation — architecture description, instructions on adding new companies.
- Admin API and panel — full functionality for managing organizations, tariffs, and monitoring.
- Isolation tests — report confirming isolation results.
- Billing integration — connect to your billing system (Stripe, PayPal, invoice).
- Training — demonstrate the admin panel to your team.
Timeline: 3 to 5 weeks depending on complexity. We calculate the exact cost for your scenario. Contact us for a consultation.
We guarantee full data isolation for each company. This approach has been proven in 10+ projects with over 50 organizations in total. Request a project assessment—we'll explain how to implement multi-company Paperclip deployment with minimal risks.