So your platform engineering effort keeps getting tangled in Identity and Access Management (IAM), network micro-boundaries, and audit evidence. The good news is there’s usually a root cause: you’re missing a clear, first-class logical boundary for everything developers touch.
In DuploCloud, that boundary is the Tenant.
Getting Tenants right gives you clean isolation, simpler security, and faster audits. You’ll also have a natural way to plug in AI agents that actually help rather than freewheel.
Below, we provide a deep, technical tour of why the Tenant model is the right foundation. We'll also look at how DuploCloud implements it. Finally, we’ll show you how the AI Help Desk and other agentic workflows slot in on day one.
What a Tenant is, and why it matters
In DuploCloud, a Tenant is a project or workspace that lives under an Infrastructure. This infrastructure maps to your cloud VPC boundary. Meanwhile, the Tenant provides the next layer of isolation across security controls, like:
- Security Groups
- IAM roles and instance profiles
- Kubernetes namespaces
- KMS keys
This is a first-class construct in the platform, not just a naming convention.
This separation gives you two powerful levers:
- Blast-radius control: At the right granularity, you can keep Dev, QA, and Prod separate without duplicating entire VPCs for every environment.
- Policy clarity: Compliance and security guardrails attach to Tenants in a way developers can understand and auditors can verify.
DuploCloud’s application-focused interface keeps users working with cloud services (S3, RDS, Lambda, EKS, etc.) inside a Tenant. Meanwhile, our platform handles all the hidden details of IAM, networking, and encryption.
How Tenants map to real guardrails
DuploCloud codifies isolation by assembling and wiring the right cloud primitives. And we do it automatically:
- Network: per-Tenant Security Groups allow intra-Tenant traffic while default-deny blocks the rest.
- Identity: per-Tenant IAM roles and instance profiles scope workload credentials.
- Secrets and encryption: KMS keys and secret stores are attached with least-privilege policies.
- Compute and containers: Tenant-scoped namespaces and service accounts govern EKS and serverless.
These are DuploCloud constructs, so your Terraform provider code will reflect the same logical boundary that your auditors will ask about.
Cross-Tenant where you need it, isolated where you don’t
DuploCloud also supports Cross-Tenant access. This means you can selectively share resources like an S3 bucket. You’ll also be able to allow controlled traffic from a shared “platform” Tenant into app Tenants.
As a bonus, you can keep everything else locked down by default.
Compliance: make the Tenant your unit of proof
DuploCloud encodes NIST 800-53 controls directly into the platform, then maps them to frameworks like SOC 2, HIPAA, PCI, and others. Since a Tenant is the logical boundary for a product or environment, it becomes the unit of compliance with consistent evidence and continuous checks.
By using these logical boundaries, DuploCloud fast-tracks out-of-the-box compliance. The team, of course, sits in on hundreds of audits a year across SOC 2, HIPAA, HITRUST, PCI, ISO, and GDPR.
Practical benefits:
- Scope clarity: Your “Prod” Tenant is your SOC 2 in-scope boundary, not a spreadsheet.
- Least privilege by default: Tenant IAM roles enforce correct scoping without developer intervention.
- Evidence on rails: Drift detection and continuous monitoring tie directly to a Tenant, making auditor sampling straightforward.
Developers build faster because the platform matches how they think
With DuploCloud:
- Developers self-serve services inside a Tenant through the no-code portal or the Terraform provider.
- Platform teams encode policy once as Plans and Tenant templates.
- IaC stays small. Since the provider understands Tenants, your Terraform is shorter and maps to the logical model.
Example:
provider "duplocloud" {
host = var.duplo_host
username = var.duplo_user
password = var.duplo_pass
}
resource "duplocloud_tenant" "prod" {
name = "acme-prod"
plan_id = duplocloud_plan.pci.id
}
resource "duplocloud_aws_host" "api_nodes" {
tenant_id = duplocloud_tenant.prod.tenant_id
friendly_name = "api-node-01"
capacity = "t3.large"
agent_platform = "eks"
}
You can also integrate directly with CI using GitHub Actions + Terraform.
Self-hosted control plane
DuploCloud runs inside your account as a VM with an instance profile or identity. Our platform manages your resources through the cloud provider APIs. It also coexists with any direct changes you make in the console or via native tools.
Unlike Heroku or other PaaS, your workloads are native cloud resources. They keep running even if DuploCloud is offline.
How AI Help Desk and agents attach to Tenants
DuploCloud’s AI Help Desk is a collaborative interface for working with specialized DevOps agents in real time. The Tenant boundary is what makes it safe and auditable:
- Scoped execution: Agents run inside Tenant guardrails, using least-privilege IAM.
- Collaborative workflow: Changes show in a shared console with approvals.
- Continuous remediation: Drift detection and compliance monitoring provide the data agents need to propose and execute fixes.
- Extensibility: You can create new agents and point them at Tenants rather than at your whole account.
The bottom line? Agents need a context window. The Tenant is that context.
End-to-end example: new customer rollout with SOC 2 in mind - Our team does this for you, but it helps to understand.
- Create Tenants: Provision acme-dev, acme-stg, and acme-prod in your shared Infrastructure with Plans.
- Deploy services: Add workloads with Terraform or portal; policies and KMS keys apply automatically.
- Cross-Tenant sharing: Grant read-only access from an “observability” Tenant into each application Tenant via cross-Tenant rules.
- AI-assisted operations: The AI Help Desk triages an alert in staging, runs a safe fix with approval, and records evidence tied to that Tenant.
- Audit ready: SOC 2 auditor samples Prod Tenant; controls and evidence are already codified.
Why this beats team-only or label-only models
- Developer experience aligns with reality. Teams think in environments, and Tenants reflect that.
- Security becomes composable. You can implement cross-Tenant rules where you need to, and you get strong isolation by default.
- Compliance is continuous. You’ll get built-in NIST controls and monitoring.
- AI augmentation stays safe. You’ll always have a least-privilege context that keeps your agents under control.
Getting started
If you’re ready to get started, we’re here to help. Here are the next steps for implementing Tenant:
- Read the Tenant docs and Infrastructure overview.
- Try the Terraform provider with a test Tenant.
- Turn on the AI Help Desk for your staging environment. This gives you visibility into agentic workflows in action.
In the end, when you make Tenants the backbone of your platform, you simplify security, shorten audits, and unlock safe automation. You also give your AI helpers a clear perimeter and a shared language to collaborate with your engineers. That’s how platform engineering moves from a ticket queue to a true product.
