ProfessionalCloud platform engineering
Multi-environment Azure platform for a public-sector modernisation programme
Five complete Azure environments — sbx to prod — across two releases, with 40+ services spanning platform, data, AI and integration layers, provisioned through Terraform modules and Azure DevOps pipelines.
- Role
- Cloud DevSecOps Engineer — infrastructure provisioning, module development, architecture documentation
- Context
- ALIANDO · Cloud Platform area
- Period
- 2026
Client-confidential details (names, identifiers, network topology, sizing) are intentionally omitted. Diagrams show the logical design only.
01Overview
A national-scale tax-administration modernisation programme needed its Azure estate built consistently, environment after environment and release after release. My work was turning that estate into code — Terraform modules executed by Azure DevOps pipelines — and keeping deployments moving when dependencies between layers blocked them.
02Context
The engagement sits in ALIANDO’s Cloud Platform area, focused on cloud infrastructure modernisation and DevOps automation for an international public-sector client. The platform spans five environments (sandbox, development, QA, pre-production and production) and was delivered in successive releases — Release 0 and Release 1.
03Problem statement
More than forty Azure services across networking, data, AI and platform layers had to exist identically in every environment, with dependencies between them (identity, secrets, networking, data services) that make ordering and configuration drift real risks. Manual or per-environment provisioning would not scale to five environments and multiple releases, nor survive audit.
04My responsibilities
- Provisioned complete environments (sbx, dev, qa, pre, prod) for Release 0 and Release 1 through Terraform modules and Azure DevOps pipelines.
- Developed custom Terraform modules where existing ones did not cover the requirement.
- Troubleshot failed deployments and unblocked cross-layer dependencies so releases could progress.
- Delivered and operated OpenShift UPI clusters on Azure, automating provisioning and lifecycle management with Terraform and Azure DevOps.
- Contributed to Solution Designs, ADRs, HLDs, LLDs, architecture diagrams and Bills of Quantities.
05Architecture overview
Every environment is described by the same Terraform codebase and differs only in configuration. Azure DevOps pipelines run plan and apply per environment. Each environment hosts the same logical layers — a platform layer (OpenShift UPI nodes, Container Registry, Key Vault, Redis Cache, Storage, IaaS VMs), a data layer, an AI layer and integration services — on top of a networking layer whose topology is intentionally not shown here.
- External / reference
- Code & configuration
- Delivery & automation
- Azure service
- Platform / runtime
- Security control
- Data & storage
Logical service map based on the services listed in my CV. Network topology, naming, identifiers and sizing are confidential and omitted.
Text description of the diagram
Architecture documentation informs Terraform modules stored in Git; Azure DevOps pipelines run plan and apply against five environments (sbx, dev, qa, pre, prod). Each environment contains a platform layer, a data layer, an AI and integration layer, and a networking layer.
Flows
- Architecture docs → Terraform modules (informs)
- Terraform modules → Azure DevOps (PR)
- Azure DevOps → Environments · R0 / R1 (per env)
- Environments · R0 / R1 → Each environment — logical service layers (40+ services) (provisions)
Components
Architecture docs · Terraform modules · Azure DevOps · Environments · R0 / R1 · OpenShift UPI · Container Registry · Key Vault · Redis Cache · Storage · IaaS VMs · ADLS Gen2 · Data Factory · Databricks · SQL Database · PostgreSQL Flex · Data Explorer · Azure OpenAI · AI Search · Azure ML · Functions · Logic Apps · Event Hubs · Notification Hubs · Networking layer
06Technology stack
- Infrastructure as Code
- Terraform
- Custom modules
- Delivery
- Azure DevOps pipelines
- Git
- Platform
- OpenShift UPI on Azure
- Container Registry
- Key Vault
- Redis Cache
- Storage Account
- IaaS VMs
- Data
- ADLS Gen2
- Data Factory
- Databricks
- SQL Database
- PostgreSQL Flexible Server
- Data Explorer
- Event Hubs
- AI & integration
- Azure OpenAI (GPT-4o)
- Azure AI Search
- Azure Machine Learning
- Azure Functions
- Logic Apps
- Notification Hubs
07Implementation approach
- One Terraform codebase for every environment; environments differ by configuration, not by code — the precondition for parity between sbx and prod.
- Services composed from reusable modules, with custom modules written where a requirement was not covered.
- Azure DevOps pipelines as the only deployment path, so every change to an environment is planned, applied and recorded the same way.
- OpenShift UPI clusters on Azure handled as infrastructure code too — provisioning and lifecycle steps automated through Terraform and pipelines rather than run by hand.
- Architecture artefacts (Solution Designs, ADRs, HLDs, LLDs, BoQs) maintained alongside the implementation so decisions stay traceable.
08Challenges & engineering decisions
Challenge
Deployments blocked by dependencies between layers — a data or AI service cannot be completed until the platform resources it relies on exist and are reachable.
Decision
Treat dependency unblocking as engineering work — trace failures to the missing prerequisite, fix it in the module or configuration, and re-run through the pipeline instead of patching the environment manually.
Challenge
Requirements that existing modules did not cover.
Decision
Write custom modules rather than inline one-off resources, so the gap is closed once for every environment.
Challenge
Running OpenShift with user-provisioned infrastructure (UPI) on Azure, where the platform team owns the underlying infrastructure.
Decision
Automate provisioning and lifecycle management with the same Terraform + Azure DevOps toolchain used for the rest of the estate.
09Security considerations
- Secrets and keys centralised in Azure Key Vault as part of each environment rather than embedded in code or pipelines.
- Pipeline-only changes give a reviewable, auditable trail for every modification to the platform.
- Client architecture, network design and identifiers are confidential — this case study describes the approach, not the estate.
10Operational considerations
- Environment parity makes issues reproducible in lower environments before they reach production.
- Successive releases extend the same codebase instead of starting new, divergent deployments.
- Lifecycle operations on OpenShift clusters run through automation, reducing manual intervention on critical infrastructure.
11Results & impact
- Complete environment set (sbx, dev, qa, pre, prod) provisioned for Release 0 and Release 1.
- 40+ Azure services across networking, data, AI and platform layers delivered through Terraform and Azure DevOps.
- OpenShift UPI clusters on Azure delivered and operated with automated provisioning and lifecycle management.
12Lessons learned
- Environment parity is a property of the codebase, not of discipline — if environments share code and differ only by configuration, drift has nowhere to hide.
- Much of real IaC work is dependency management between layers; modules should make those dependencies explicit.
- Architecture documents and code should evolve together; an ADR is most useful when the implementation it justifies is one pull request away.