Skip to content

I'm currently populating my catalog on the site. Pardon the prefilled data. The entries are actively being updated and cleaned up.

Previous website

Containerised Application Delivery on AWS ECS

End-to-end deployment of a Node.js frontend and backend on AWS ECS Fargate, automated through a Jenkins CI/CD pipeline and provisioned with Terraform.

Role: DevOps EngineerTimeline: 72 hoursCategory: CI/CD
  • AWS ECS Fargate
  • Jenkins
  • Terraform
  • Docker
  • ECR

Overview#

This project treated delivery as a confidence workflow rather than a single deployment event. Each stage in the release path had a clear purpose, observable state, and rollback-aware boundary.

Problem#

Existing pipelines were fast enough for simple releases but not clear enough when production risk increased. When checks failed or rollout health degraded, it was not obvious where the release was blocked or what the next safe action should be.

Solution#

I split the workflow into explicit build, verify, sign, promote, observe, and production stages. That structure made the release path easier to explain and easier to trust under pressure.

Architecture#

The release system was modeled as a sequence of state transitions with explicit verification points.

Tech Stack#

  • AWS ECS Fargate
  • Jenkins
  • Terraform
  • Docker
  • ECR
YAML
stages:  - build  - verify  - sign  - promote-staging  - observe  - promote-production

Key Features#

  • Signed artifacts before promotion.
  • Clear environment promotion boundaries.
  • Observation windows before auto-promotion.
  • Rollback-ready release design.

Media#

A placeholder operations view representing rollout checks and release status visibility.

Results#

The system reduced ambiguity around rollout state and made production promotion more operationally calm. Teams could see where trust was being established rather than assuming the pipeline had everything under control.

Lessons Learned#

The delivery system became more valuable once its state transitions were explainable. Reliability improves when pipeline behavior is explicit enough for teams to reason about it together.

Related Projects

A few additional builds that connect to the same infrastructure, delivery, and reliability themes.

Enterprise AWS Platform Engineering

A production-grade cloud platform built on AWS EKS with Terraform environment isolation, polyglot CI/CD across Node.js, Java, and Rust, GitOps via ArgoCD, and a layered security scanning strategy — end to end.

  • AWS EKS
  • Terraform
  • GitHub Actions
  • ArgoCD
  • Helm
  • Docker
  • ECR
  • Prometheus
  • Grafana

Kubernetes Workload Platform on AWS EKS

Provisioned a production-grade EKS cluster on AWS with Terraform, deployed containerised workloads using Helm, and automated the full delivery pipeline with Jenkins.

  • AWS EKS
  • Terraform
  • Jenkins
  • Helm
  • Docker
  • ECR

Multi-Region Platform Resilience

A disaster recovery and high-availability architecture across two AWS regions using Route 53 failover, cross-region RDS replication, and automated runbooks for recovery validation.

  • AWS Route 53
  • RDS Multi-Region
  • Terraform
  • CloudWatch
  • Lambda
  • S3