I'm an Azure Cloud Engineer with 10 years of experience designing and operating cloud-native infrastructure on Microsoft Azure. I specialise in infrastructure as code with Terraform, container orchestration with Kubernetes, and end-to-end CI/CD automation using GitHub Actions.
I fell into cloud engineering by accident — a broken Azure deployment that took a weekend to fix. That weekend taught me more about distributed systems than any course. I've been chasing that feeling of "finally understanding how it works" ever since.
Today I work as an Azure Cloud Engineer, focused on AKS, Terraform, GitHub Actions, and Go-based tooling. I care about the developer experience because I've seen what happens when infrastructure is a wall instead of a launchpad.
Engineering is as much about culture and craft as it is about technology. These are the principles I bring to every team, every project, every pull request.
A feature nobody can use is worse than no feature at all. I design for failure first — because distributed systems will fail — and build observability in from day one, not as an afterthought.
Infrastructure, security policies, runbooks, architecture diagrams — if it can be in a repository, it should be. Version control is the foundation of repeatability, auditability, and trust.
If an engineer has to do the same thing twice, the third time should be a script. If three engineers do it weekly, it should be a self-service platform. Toil is engineering debt you can measure in hours.
Zero-trust isn't a product you buy — it's a mindset you build into every layer. Security reviews in design reviews, not post-deployment. Least privilege everywhere, always.
You cannot improve what you cannot see. I instrument everything with meaningful metrics, structured logs, and distributed traces before I think about performance. Data drives decisions, not intuition.
Knowledge that stays in one person's head is a single point of failure. I write documentation like I'm writing it for a future version of myself at 2 AM during an incident — because I've been that person.
The best infrastructure is invisible. I aim for systems so stable, so automated, and so well-observed that on-call means catching up on reading.
If it's not in a repository, it doesn't exist reliably. Infrastructure, policies, runbooks, diagrams — all versioned, reviewed, and continuously tested.
Security, cost, and operational concerns belong in the design phase, not the post-mortem. Early constraints produce better architecture.
Internal platforms have real customers — developers. Adoption is never mandatory. If engineers choose the golden path, the platform is genuinely good.
Whether it's a greenfield platform or a fire-fighting engagement, I follow the same disciplined process. It's been refined over seven years and forty-plus projects.
Every engagement starts with listening — to engineers, to architects, to on-call war stories. I read the last six months of post-mortems before writing a single line of Terraform. Context shapes architecture.
I write architecture decision records before I draw diagrams, and diagrams before I write code. The RFC process exists because good decisions come from documented reasoning, not from whoever spoke last in the Slack thread.
I write infrastructure code with the reviewer in mind — clear variable names, module interfaces that reveal intent, comments that explain why, not what. Readable IaC is maintainable IaC, and maintainable infra is a competitive advantage.
Dashboards, runbooks, SLOs, and alert thresholds are delivery artefacts as much as the infrastructure itself. A system you can't understand in production at 2 AM isn't finished. I ship observability alongside code.
Every incident is a free lesson in how real systems fail. I run blameless post-mortems, track action items to completion, and feed findings back into the design process. The goal isn't zero incidents — it's incidents that never repeat.
Leading cloud automation initiatives, building reusable Terraform modules, and enabling GitOps-driven infrastructure across Azure.
Supported cloud infrastructure operations and automated routine processes using scripting and Infrastructure as Code.
Specialized in computer science fundamentals, software engineering, and systems design.
Demonstrates proficiency in Infrastructure as Code, Terraform workflows, and best practices.
Validates expertise in designing secure, scalable, and resilient Azure architectures.
Open to senior platform engineering and cloud architecture discussions. Reach out on LinkedIn for professional enquiries.
