Sukhraj Singh
All projects

DevOps & reliability · 2026

DeployGuard

Safer releases. Automatic rollbacks. A clear audit trail.

Local controller · Cloud blueprintIndependent project

My contribution

I designed and implemented the release controller, SLO gates, rollback behavior, audit trail, tests and infrastructure blueprints.

Evidence

Repository, automated checks, Prometheus output, audit records and a 61-second application walkthrough.

Scope & limitations

The AWS EKS and Kubernetes blueprints are reviewable but have not been provisioned in a live cloud account.

  • AWS
  • Kubernetes
  • Terraform
  • Helm
  • Prometheus
  • Docker

See it in action.

01:01 · Visual walkthrough
Start canary -> verify delivery path -> evaluate SLOs -> promote healthy stages -> roll back a breach -> inspect the audit trail.
About this demonstration

A concise visual walkthrough built from the repository's verified release stages, SLO thresholds, security checks, rollback behavior and audit model. On-screen subtitles explain every decision, accompanied by a soft motivational beat.

Start canary -> verify delivery path -> evaluate SLOs -> promote healthy stages -> roll back a breach -> inspect the audit trail.

The problem & approach

The problem

A deployment can be technically successful and still damage reliability. I wanted promotion to depend on observable service health instead of a manual guess, while keeping the release decision, rollback reason and infrastructure controls easy to inspect.

The approach

DeployGuard is a working release-control application backed by production-oriented infrastructure blueprints. It moves a canary through 10%, 25%, 50% and 100% traffic stages, evaluates p95 latency and error-rate SLOs before every promotion, and records an automatic rollback with the reason when a gate fails.

How it works
  1. 01Release dashboard
  2. 02Deployment controller
  3. 03SLO analysis gate
  4. 04Traffic promotion or rollback
  5. 05Prometheus metrics
  6. 06GitHub Actions security checks
  7. 07AWS EKS via Terraform + Helm
  • I implemented a working release controller that advances canary traffic through 10%, 25%, 50% and 100% stages.
  • I added p95 latency and error-rate gates so every promotion has an explicit reliability contract.
  • I made failed gates trigger an automatic rollback and persist the reason in a production-style audit trail.
  • I exposed Prometheus-format metrics so release state and gate outcomes can be observed outside the dashboard.
  • I created hardened Kubernetes resources with non-root execution, a read-only filesystem, probes, limits, HPA, PDB and NetworkPolicy.
  • I modelled a private-subnet AWS EKS control plane, ECR image scanning, IAM and audit logging with Terraform and Helm.
  • I added unit tests, policy-as-code validation, Trivy scanning and container builds to the GitHub Actions path.
Technical decisions & lessons

SLO gates

I used measurable latency and error-rate thresholds to decide whether a release deserves more traffic.

Automatic rollback

I made the safest response deterministic when a canary violates its reliability contract.

Prometheus

I exposed release decisions as operational data instead of leaving them only in the interface.

Kubernetes + Helm

I modelled the workload, scaling and disruption controls as repeatable platform configuration.

Terraform on AWS

I kept the EKS, ECR, IAM and audit-log blueprint reviewable before any billable deployment.

Challenges

  • I had to keep promotion state deterministic while still making latency and error injection useful for an interactive local demo.
  • I separated the fully working local controller from the AWS and Kubernetes blueprints, which require a real account and billable resources to deploy.
  • The security path needed to cover application tests, policy checks, repository scanning and the final image without treating one green check as complete assurance.

What I learned

  • I learned to treat deployment as a sequence of evidence-based decisions rather than one binary event.
  • I learned how SLOs, observability and rollback logic become part of the delivery platform itself.
  • I learned to pair a working local control plane with honest boundaries around cloud infrastructure that has not been provisioned.
  • I learned how runtime hardening, policy-as-code and image scanning support—but do not replace—reliability gates.

Progressive delivery contract · release model

10% -> 25% -> 50% -> 100%

for each stage:
  evaluate p95 latency + error rate
  pass -> promote
  fail -> rollback + audit reason