Prompt
I need IaC that supports both app teams and platform teams
Latest observation
Absolutely. If you want IaC that works for both app teams and platform teams, the key is to design for two different operating models:
- App teams need speed, simplicity, guardrails, and minimal cloud expertise.
- Platform teams need control, consistency, security, and the ability to scale patterns across many services.
Recommended approach
Use a layered IaC platform:
1. Platform layer
Managed by platform/infrastructure teams.
Responsible for:
- network, IAM, clusters, shared databases, observability, DNS, security policies
- baseline environments and landing zones
- reusable modules/templates
- policy enforcement and access boundaries
Tools/patterns:
- Terraform / OpenTofu modules
- Crossplane for cloud abstraction
- Pulumi or CDK if your org prefers general-purpose languages
- Policy as code: OPA/Conftest, Sentinel, Terraform Cloud policies
- GitOps for cluster-based workloads: Argo CD / Flux
2. Application layer
Managed by app teams.
Responsible for:
- deploying services, config, secrets references, queues, cron jobs, app-specific DBs
- consuming platform-provided abstractions
- self-service environments
Should expose:
- simple inputs
- opinionated defaults
- strong guardrails
- limited surface area
Good interfaces:
- parameterized modules
- golden path templates
- internal developer platform (IDP) portal workflows
- GitOps app definitions
What makes this work for both groups
For app teams
Give them:
- a small set of approved building blocks
- self-service templates
- sensible defaults
- automated previews and validation
- no direct access to fragile primitives
Example: “Create a web service” template provisions:
- service account
- deployment
- ingress
- logs/metrics
- optional database or queue binding
For platform teams
Give them:
- composable primitives
- reusable modules
- centralized policy
- environment/account structure management
- observability and cost controls
Example: platform manages:
- AWS org / Azure subscriptions / GCP folders
- VPC/VNet
- EKS/GKE/AKS clusters
- shared ingress and service mesh
- baseline security controls
Good design principles
1. Separate concerns
Don’t force app teams to understand networking, IAM, or provider quirks.
2. Standardize interfaces
Every module should have:
- clear inputs/outputs
- versioning
- documentation
- examples
3. Prefer opinionated defaults
Less choice means less friction and less drift.
4. Apply policy centrally
Use guardrails instead of tribal knowledge:
- allowed regions
- encryption required
- tagging required
- instance size limits
- network restrictions
5. Make the path of least resistance the right path
Templates, pipelines, and portals should make compliant infrastructure easier than ad hoc changes.
Example operating model
Platform team owns
- landing zones
- shared modules
- CI/CD templates
- guardrails
- base runtime platform
- secrets and identity integrations
App team owns
- app definition
- app configs
- workload-specific resources
- deployment manifests
- runtime tuning within allowed constraints
Suggested stack examples
If you want maximum compatibility
- Terraform/OpenTofu for infrastructure
- Helm/Kustomize for Kubernetes apps
- Argo CD or Flux for GitOps
- OPA/Gatekeeper or Kyverno for policy
- Backstage for developer self-service
If you want a more developer-friendly IaC model
- Pulumi for general-purpose language IaC
- Crossplane for platform abstractions
- GitOps for app delivery
- Policy as code for guardrails
A practical pattern that works well
Use three layers:
- Foundational infra
- platform only
- Composable platform services
- owned by platform, consumed by app teams
- Application workloads
- owned by app teams
This gives you:
- strong central control where needed
- self-service where it matters
- reduced ticketing and manual operations
If you want a simple rule of thumb
- Platform teams define the paved roads.
- App teams drive on them.
- Neither should build the highway from scratch every time.
If you want, I can also give you:
- a reference architecture diagram,
- a recommended toolchain by cloud provider,
- or a sample repo structure for platform + app team IaC.