Skip to content
Back to case studies
NDA-safeCloud Architecture2025

Enterprise IaC Standardization

Manual VPC sprawl + quarterly audit pain → standardized IaC, 70% faster setup, findings down 47 → 3.

Reported engagement figures. See the results section for measurement context and limitations.

Role
Senior AWS Solution Architect
Context
Enterprise / Data & AI (NDA)
Duration
Ongoing (6+ months)
Team
2 senior architects (me + 1) mentoring 8 junior engineers

Why they called

Fourteen VPCs had been built by hand across the accounts, with overlapping subnets, inconsistent CIDR ranges and no tagging. Every project carried its own security posture, a new environment took two to three weeks, drift was causing about a dozen incidents a month, and the quarterly security audit was returning 47 findings.

Tech stack

  • AWS
  • VPC
  • RDS
  • Terraform
  • CloudFormation
  • MySQL
Executive summary

Business problem and production context.

Business problem

Enterprise teams were provisioning AWS resources by hand, and every project had its own VPC layout, security posture and deployment pattern. That meant drift between environments, audit findings that came back every quarter, and new environments that took 2-3 weeks to stand up.

Architecture decision

With one other senior architect, I designed a reference architecture for VPC, compute and database, then encoded it as Terraform modules with secure defaults and documented overrides. Teams that do not write Terraform get the same patterns as Service Catalog products built on CloudFormation. Weekly review workshops with the junior engineers explained why each default exists, so the team can extend the modules without us.

Result

Before and after.

Figures below come from the engagement account. Where no measurement source or period is provided, they are labelled reported. Workload scale, targets and engagement outcomes are different measures; past results are not a forecast for another system.

New Environment Setupreported
Before2-3 weeks (manual)
After45 minutes (IaC)
Security Audit Findingsreported
Before47 per quarter
After3 per quarter
Infra Drift Incidentsreported
Before12/month
After0
Cloud Spend Visibilityreported
BeforeNone
AfterPer-team, per-service dashboards
Architecture

Teams provision AWS environments from reviewed modules with secure defaults instead of building them by hand, and every resource is checked for tags that drive cost reporting.

How a change becomes a provisioned environment and what checks it afterwards. The account structure, the workloads inside each environment and the module internals are not shown.

Simplified view

Main components only; supporting services are left out.

  1. 1. Provisioning paths

    • Pull request review

      Architects review module changes

    • Terraform modules

      Secure defaults, documented overrides

    • Service Catalog products

      Self-service without Terraform

    • CloudFormation

      Backs the Service Catalog products

  2. 2. Provisioned environment

    • Secure VPC

      Standard subnets, NAT, flow logs

    • RDS (MySQL)

      Standard database module

    • ECS

      Standard compute module

    • IAM

      Standard access module

  3. 3. Compliance and cost

    • AWS Config rules

      Enforce required tags

    • Cost dashboards

      Spend per team and service

How it works, step by step

  1. 1An engineer changes an environment through a pull request on the Terraform modules, reviewed with the architects in the weekly workshop.
  2. 2Terraform applies the VPC, RDS, ECS and IAM modules with their secure defaults, using a documented override only where a team needs one.
  3. 3Teams that do not write Terraform get the same patterns as Service Catalog products built on CloudFormation.
  4. 4AWS Config rules check the provisioned resources for the required tags.
  5. 5Those tags feed the per-team, per-service cost dashboards.

Guardrails

  • Secure defaults in every module, with documented override escape hatches
  • Consistent CIDR allocation with public, private and isolated subnets
  • VPC flow logs on by default
  • Pull request review of module changes
  • Tagging enforced by AWS Config rules

Considered and not used

  • AWS Landing Zone: Custom modules chosen for flexibility while keeping compliance guardrails.
  • Aurora: RDS chosen for predictable workloads where Aurora's auto-scaling would add cost without benefit.
What Rahul owned

My part of the work, separate from the team's.

The team behind the engagement is in the facts row above. These are the parts I was responsible for, and the artifacts that show the work.

Owned scope

  • Standardized cloud architecture templates with secure network, compute, and database patterns
  • Reusable IaC patterns and workshops so junior engineers understood why decisions were made
  • Enterprise guardrails around accounts, security, and repeatable provisioning

Evidence artifacts

Terraform and CloudFormation templatesJunior architect mentoringManual setup reductionEnterprise cloud standards
Constraints

What would fail first?

Every project has constraints. The useful work is naming them early enough that rollback, cost, and ownership are designed before an incident.

Enterprise compliance

Architecture needed to support secure defaults, repeatability, and audit-friendly implementation.

Team scaling

Junior engineers needed reusable patterns and decision context, not only templates.

Manual setup

Manual provisioning had to shrink so environments were consistent and easier to review.

Decision table

Trade-offs accepted on purpose.

Terraform vs CloudFormation
Used both.
Terraform for multi-account orchestration, CloudFormation for AWS-native Service Catalog integration.
RDS vs Aurora
RDS chosen for predictable workloads where Aurora's auto-scaling would add cost without benefit.
Custom modules vs AWS Landing Zone
Custom modules for flexibility while maintaining compliance guardrails.
Risk table

Production risks and how they were controlled.

Templates copied without judgment
Paired IaC modules with workshops explaining constraints, trade-offs, and owner responsibilities.
Architecture lead
Security drift after provisioning
Built secure defaults and reviewable IaC contracts instead of one-off console changes.
Cloud platform team
Manual setup blocked delivery
Standardized repeatable patterns for common compute, network, and database paths.
Platform + app teams
Implementation approach

Small steps, visible changes, fewer surprises.

  1. 01

    Audited existing AWS accounts and found 14 manually provisioned VPCs with inconsistent CIDR ranges, overlapping subnets, and no tagging standards.

  2. 02

    Designed a reference architecture with secure VPC templates: public/private/isolated subnets, NAT gateways, flow logs, and consistent CIDR allocation.

  3. 03

    Built Terraform modules for VPC, RDS, ECS, and IAM with opinionated defaults. SOC2-compliant out of the box with override escape hatches.

  4. 04

    Created AWS Service Catalog products using CloudFormation for teams that needed self-service provisioning without Terraform knowledge.

  5. 05

    Led weekly architecture review workshops with junior engineers, reviewing their pull requests and explaining the trade-off behind each module default.

After handover

What the team runs now.

The point of the work is what the client's own engineers can change and operate without me.

  • The Terraform modules for VPC, RDS, ECS and IAM, with SOC2 defaults and documented override escape hatches.
  • Self-service provisioning through AWS Service Catalog for the teams that do not write Terraform.
  • Tagging enforcement through AWS Config rules, and the per-team, per-service cost dashboards that depend on it.
  • The architecture decisions themselves. Three of the junior engineers from the weekly review workshops now design compliant environments on their own.
Takeaway

What carries over to your system.

  • Service Catalog was essential for adoption. Teams that weren't comfortable with Terraform could still self-service compliant infrastructure through a web UI.
  • Tagging enforcement via AWS Config rules caught 90% of untagged resources within the first month. Without it, cost allocation would have remained invisible.
  • Mentoring junior architects on WHY decisions were made (not just HOW) was the highest-leverage activity. Three of them now independently design compliant architectures.

Rollback path

Infrastructure templates needed versioned changes so teams could identify and revert risky updates.

Cost considerations

Cost control came from standard defaults, reviewable environment shape, and reducing accidental overbuild.

Observability notes

The baseline included account/environment visibility, template usage, security posture, and provisioning success.

Services built on this work

Have a similar production problem?

Send the current architecture, bill concern, deployment pain, or GenAI reliability issue. I will help you find the first real bottleneck.

Scroll or pinch to zoom, drag to move100%