I architect Multi-Cloud infrastructure and the checks that make deployments trustworthy.

SaaS SRE lab: SLO burn-rate alerting and two measured DR drills

Claim. Built a SaaS-style service on AWS with explicit SLOs and burn-rate alerting, then injected five real production failures and measured how long each took to detect. Followed that with two separate disaster-recovery drills: a local Kubernetes drill that deleted a StatefulSet and its volume (RTO 92s, RPO 216s), and a real AWS drill that used RDS point-in-time restore to recover 166,721 deleted rows in under 16 minutes.

Engineering focus. Burn-rate alerting tuned against real SLOs rather than raw thresholds, and the write-up stays honest about what the numbers actually show: the RPO target was met "by timing, not design," an aggregate SLO missed a real regression that only a per-route check caught, and two tooling gaps were found and documented rather than hidden — backup jobs that failed silently and produced 0-byte files, and a backup size that shrank 17% with nothing alerting on it.

PatchPilot: patching that schedules itself around real batch workloads

Claim. Built a patch-orchestration tool that plans maintenance windows from each customer's actual batch-processing history, not just a schedule definition — then patches a mixed RHEL and Windows fleet through Salt while deliberately keeping Java and Tomcat pinned to their certified versions. It reproduces and automatically remediates two real Java-on-RHEL failure modes: SELinux silently flipping back to Enforcing and breaking app connectivity, and a Tomcat upgrade breaking a legacy screen.

Engineering focus. A planner that learns each workflow's real p95 finish time per weekday (schedules say when a job starts, not when it actually finishes), gated runs that abort cleanly before touching anything if a batch job is still running or a check already fails, and two real incidents from the AWS lab along the way: a STIG scan silently froze a database node by exhausting memory with no swap configured, and a subtler one — oscap's own output uses a separator that Python's line-splitting treats as a line break, so 4,295 lines of real scan results silently parsed into zero rules, which had already produced one false "scan ok" before it was caught. Both diagnosed through EC2 status checks, system logs, CloudWatch, and Salt's own job cache — not guessed at.

Centralized OS patching for a mixed Linux/Windows fleet, with zero inbound access

Claim. Built a mixed Amazon Linux, Ubuntu, and Windows Server EC2 fleet patched entirely through AWS Systems Manager — no server ever reachable over SSH or RDP. Measured before (164 missing patches, 1 of 4 nodes compliant) and after (0 missing, 0 failed, 3 of 4 compliant — the 4th left non-compliant on purpose as a control, to show what happens without follow-up).

Engineering focus. A custom Windows baseline and patch group routing only security/critical updates, a weekly maintenance window with concurrency and error-threshold limits, and three real issues found and fixed: a package-manager lock conflict from a duplicate patch run, a Windows security update missing from Patch Manager's own catalog (fixed via a direct Run Command, not the baseline), and a maintenance window silently pointed at the wrong SSM document, caught by checking the API instead of trusting the console.

VMware ESXi lab: real licensing limits, and monitoring proven by an injected failure

Claim. Built a nested VMware ESXi 8.0U3e environment from scratch, then found — through four separate operations that all returned the identical API error — that the free license blocks VM cloning, OVF deployment, and even reconfiguring an existing VM through the API; Terraform's vsphere provider crashed outright for a related reason. Automated configuration and monitoring with Ansible instead, and didn't stop at "deployed": stopped a monitored service on purpose and measured how long detection actually took.

Engineering focus. Diagnosing a Hyper-V/VT-x conflict that blocked nested virtualization before the VM would even power on, an Ansible playbook that hardens SSH and deploys a Python health-check tool plus a Prometheus/Grafana stack with its datasource and dashboard provisioned as code, and a firewall rule that had been silently blocking all of it until found and fixed.

Azure disaster recovery drill: VM and SQL failover

Claim. Ran two real Azure failover drills between West US and Central US and measured them: an Azure Site Recovery VM failover and an Azure SQL failover group under a live write load. RTO and RPO targets were committed to the repository before each run, and the results are published as measured, including the one target I missed.

Engineering focus. Terraform-built infrastructure, Site Recovery replication and failover, SQL failover groups, timing recovery from the recovered VM's own log, and a cost guardrail set before anything billable existed. Both labs were torn down and checked against Azure afterward.

EKS GitOps service with a measured database recovery drill

Claim. Deployed a service to EKS on Fargate with Argo CD, backed by Aurora, then ran a real recovery drill: the database was killed mid-traffic and restored while recovery time was measured against a target set beforehand. Target RTO was 2 minutes; measured recovery was 39 seconds.

Engineering focus. Terraform and Terragrunt for the VPC and cluster, GitOps delivery with Argo CD, Aurora, and diagnosing real failures along the way, including CoreDNS pods stuck Pending on Fargate and an AWS VPC quota limit that moved the deployment to another region. Everything was torn down and verified at zero cost afterward.

Hybrid Cloud Network Architecture

Claim. Built a Terraform-based network design using Transit Gateway and site-to-site VPN components, then tested rebuildability through destroy and reapply.

Engineering focus. Routing, IPsec connectivity, reusable infrastructure code, and fixing a GitHub Actions OIDC trust-policy error during deployment.

AWS Site-to-Site VPN across two regions

Claim. Built a real AWS Site-to-Site VPN — IPsec, a Virtual Private Gateway, a Customer Gateway, static routing — connecting two simulated company networks in two different AWS regions, with no router or ISP cooperation needed since both sides are AWS. Verified with an actual ping and SSH hostname check routed through the gateway and across the tunnel, not just a status light.

Engineering focus. Terraform building both VPCs and the VPN connection end to end, Libreswan configured with the real tunnel address and pre-shared key straight from Terraform’s own outputs, and two real bugs found with tcpdump after the obvious fixes did not work: IP forwarding disabled by default, and a security group that allowed the reply direction but not the forward direction — both produced the identical symptom until isolated.

Automated DR with proven RTO/RPO: scheduled chaos drills, built twice

Claim. Built multi-region AWS disaster recovery two ways — active-passive (Aurora Global Database, DynamoDB global tables, Route 53 failover) and active-active (Aurora DSQL, synchronous cross-region writes) — then proved both with AWS Fault Injection Service chaos drills that break the primary region on a schedule and publish the measured result, including the runs that failed.

Engineering focus. An automated failover runbook and an analyzer that grades each drill from client-observed data, not self-reported status. The first real drill session found two genuine bugs no local test caught: a Step Functions expression using the wrong SDK field-name casing left the runbook stuck polling for 8 minutes after Aurora had already failed over, and a DynamoDB replication link that broke before the injected fault reached every execution environment, losing 33 acknowledged writes against a 5-second RPO target — a real limit of asynchronous multi-region replication, not a bug. The active-active rebuild removed the failover step entirely: recovery is Route 53 latency routing, with 0 of 1,265 writes lost.

From Disaster Recovery to Hybrid Cloud: My Hands-On Journey in Cloud Infrastructure Engineering

Four projects, each one leading into the next — AWS disaster recovery, Azure Site Recovery and SQL failover, a VMware ESXi lab, and an AWS Site-to-Site VPN across two regions. The piece is less about the resume line each project adds and more about what connected them: the same RTO/RPO discipline, carried from cloud to cloud to on-prem.

Building the AWS Backend for a Volunteer-Matching Platform: Serverless, Terraform, and a Bug That Taught Me Something About Lambda Layers

A serverless backend for a volunteer-matching platform — Lambda, API Gateway, DynamoDB, atomic transactions to stop two volunteers claiming the same slot at once. The real story is the bug: a shared Python module Lambda refused to import, traced back to the layer's ZIP not following the required python/ folder structure. Terraform said the deploy succeeded; the endpoints said otherwise.

How I Reduced Deployment Errors with a GitHub Actions CI/CD Pipeline on AWS EC2

Manual deployment is where human error actually lives — the wrong version tagged, a validation step skipped under time pressure. The pipeline: GitHub Actions runs tests and a Trivy security scan, builds the Docker image, deploys it to an EC2 server Terraform provisioned, then checks a real health endpoint before calling it done. Same release steps, every time, with nothing left to remember.