AnantState
Cloud native and multi-tenant

Built for many tenants, isolated by design.

If several business units or customers share one installation, they must be kept apart reliably. We enforce that separation in the database itself, so a bug in the application cannot expose one group’s data to another.

In plain termsData from different groups is walled off by the database, so even a software mistake cannot mix it.

Cloud native, stated as properties

Six things that matter operationally.

PropertyWhy it matters to you
ElasticCapacity follows the number of entities modeled.
Horizontally scalableGrowth is added capacity, not a larger machine and a maintenance window.
Independently upgradableA platform upgrade does not require your data to be migrated first.
ObservableHealth, throughput and latency are first-class metrics, so your operations team can run it.
Resilient by redundancyNo single instance holds the only copy of a tenant’s state.
Deployable where you need itContainers on your own infrastructure, Kubernetes, or a cloud deployment.

Where it runs: three supported topologies

TopologyShape
Single-host containersThe whole stack in one container composition: database, API service, web application and an optional identity provider for testing.
KubernetesThe same services deployed to an environment that already runs a cluster.
Cloud with a managed databaseThe application services beside a managed database instance, with provisioning and retention scripts.

In every topology a standard relational database is the store, and a vanilla install is a fully supported target. Migrations run at boot, and the serving role is an application role with isolation enforced on it rather than a superuser. Provisioning a database and serving traffic from it are separate privileges, which is the property a security reviewer looks for first.

Three supported topologies, the same services

  1. DatabaseIn: Single-host containers
  2. API serviceIn: Single-host containers
  3. Web applicationIn: Single-host containers
  4. Identity provider: Optional, for testingIn: Single-host containers
  5. The same services: Deployed to a cluster you already runIn: Kubernetes
  6. Application servicesIn: Cloud with a managed database
  7. Managed database: An instance your team already operatesIn: Cloud with a managed database
  8. Provisioning and retention scriptsIn: Cloud with a managed database
  9. Keycylinder: A standard relational database; stack: The same services; external: Optional
The same services run in each topology. What changes is how they are hosted, and in every one the store is a standard relational database.

Isolation at the data layer, not the application

LayerControl
DataRow-level isolation enforced by the database itself, so an application defect cannot widen visibility
AccessRole and workspace evaluated on every request
IdentityPer-tenant single sign-on and provisioning
DefinitionsOntologies, domains and policies are tenant-scoped and cannot bleed across tenants
ReasoningNo shared queue or shared execution context between tenants
AuditActions recorded and queryable within the tenant boundary
MemoryTenant-scoped; retention policy applies within it

Why the data layer. If isolation is enforced in the application, one missed condition (in one query, one new endpoint, one refactor) is a cross-tenant leak. Pushing the control into the database means the application’s failure mode is closed rather than open. It is the single most important architectural security decision in the product.

Isolation is enforced by the database, not the application

  1. Tenant A usersLeads to: Application
  2. Tenant B usersLeads to: Application
  3. Application: Runs as an application role, not a superuserLeads to: Database with row-level isolation
  4. Database with row-level isolation: The control lives hereLeads to: Only Tenant A rows; Only Tenant B rows
  5. Only Tenant A rows
  6. Only Tenant B rows
Each tenant reaches the data through the same application, but the database itself decides which rows are visible, so a defect in the application cannot widen what anyone can see.

No noisy neighbors

Because a shared queue is a shared fate.

  1. No shared execution context between tenants

    One tenant’s heavy reasoning does not occupy the queue another tenant’s live operation depends on.

  2. Reasoning can run where the decision is made

    Including locally in a browser, so analytical load does not compete with the live stream. See low latency.

  3. Per-tenant scale

    Capacity is provisioned against the entities a tenant models, so a large tenant does not set the cost or the latency floor for a small one.

Review the isolation model with your security team

We will walk your reviewers through the tenancy layers above and answer their questionnaire directly.