Platform & DevSecOps Engineer
OLAMIDE
OLALEKAN
Most infrastructure fails silently — then catastrophically.
I build platforms where failure is designed for, not discovered in production.
The engineers CTOs trust most are not the ones who prevent every failure. They are the ones who make recovery so fast it stops mattering. That is the standard I build to.
🌍 velrite.github.io · Kubernetes · GitOps · Terraform · Reliability Engineering

ENGINEER BY TRAINING.
SYSTEMS THINKER BY INSTINCT.

My foundation is Mechatronics — a discipline that forces you to hold mechanical, electrical, and software systems in your head simultaneously. That training shaped how I approach infrastructure: not as a collection of tools, but as a system with failure modes to anticipate and contain.

"Failure is inevitable. The goal is to make recovery predictable."

I work at the intersection of reliability engineering, deployment governance, and infrastructure automation — building platforms that are boring to operate because they handle the hard parts themselves. Former lead instructor. I build things and explain them clearly.

Core Stack

  • Kubernetes
  • Terraform
  • Docker
  • ArgoCD
  • Argo Rollouts
  • Prometheus
  • GitHub Actions
  • AWS
  • Helm
  • Vault
  • OpenCost
  • Python

Disciplines

  • Reliability Engineering
  • GitOps & Progressive Delivery
  • Infrastructure as Code
  • Zero-Trust Security

FIVE DISCIPLINES.
ONE OPERATING STANDARD.

01

Reliability Engineering

Simulated node failures recovered in 20–46 seconds automatically. Failure is expected, isolated, and recovered from — without human intervention.

02

GitOps & Progressive Delivery

Git as the single source of truth. Configuration drift detected and reconciled automatically. Canary deployments promoted or rolled back based on real-time SLOs.

03

Infrastructure as Code

Entire environments provisioned declaratively. Reproducible from a single command. The state file owns the truth. No manual configuration. No drift.

04

Zero-Trust Security

Network segmentation, non-root containers, no static credentials anywhere. Deployment failures contained — no observed customer impact.

05

FinOps & Cost Visibility

Full cost attribution per service from day one. No surprise cloud bills. Every dollar traced to a workload.

BUILT IN PUBLIC.
NUMBERS BEHIND EVERY CLAIM.

AUTO-HEALING PLATFORM GitHub Actions CI/CD K8s Control Plane Node 1 ✓ healthy Node 2 ✗ FAILED evicting pods… Node 3 ✓ rescheduled Prometheus Grafana Vault OpenCost recovery: 20–46s · rollback: 32s · zero human intervention
Reliability Engineering

Auto-Healing Kubernetes Platform

In plain terms: When a server hosting part of your application dies, this platform notices within seconds, moves the work to a healthy server, and keeps your app running — with no engineer paged at 3am.

Problem: Most Kubernetes setups are built to work under ideal conditions. Node failures expose gaps that were never designed for.

Decision: Build the entire platform around failure as a design input. Every component recovers automatically — no human required.

⚡ Node recovery: 20–46s  ·  Rollback: 32s  ·  No customer impact observed
Architecture
GitHub Actions → Control Plane → 3 Worker Nodes → Prometheus → Grafana → Vault → OpenCost. Every layer observable and automated.
Failure Scenario
Simulated node failure mid-workload. Control plane detected the unresponsive node, evicted pods, rescheduled to healthy nodes automatically — across multiple test runs.
Key Tradeoff
Readiness probe gating over speed — deployments roll out slightly slower but bad versions never reach traffic. Slower rollout, zero customer-facing failures.
Result
Recovery bounded at 20–46s. Rollback at 32s. Platform operates identically whether a human is watching or not.
TERRAFORM PLATFORM Git Repository terraform apply state file = truth monitoring ns app ns security ns infra ns reproducible · declarative · no drift · single command
Infrastructure as Code

Terraform Kubernetes Platform

In plain terms: The entire cluster setup is written as code. Need a copy of the whole environment? One command rebuilds it exactly — no tribal knowledge, no manual clicking.

Problem: Managing infrastructure with kubectl means mentally tracking what was applied. That breaks down under pressure.

Decision: Move everything to Terraform so the state file owns the truth — not memory, not hope.

⚡ Declarative across 4 namespaces  ·  Zero manual kubectl  ·  Drift detectable at any time
Architecture
Git → terraform apply → state file → 4 namespaces (monitoring, app, security, infra). Vault for secrets. OpenCost for spend. All resources declared, none manually applied.
Core Problem Solved
kubectl apply works until it doesn't. Under incident pressure, humans forget what was applied. Terraform eliminates that failure mode — the plan always shows the diff between intent and reality.
Key Tradeoff
Terraform state requires careful management — it becomes a liability without remote state locking and a strict no-manual-changes policy. Both implemented from day one.
Result
Entire platform reproducible from a single terraform apply. Any engineer can onboard by reading the modules — no tribal knowledge required.
DOCKER PLATFORM Git Commit (pinned sha) Trivy scan every build network: frontend nginx non-root flask app 186MB · non-root network boundary network: backend postgres isolated redis isolated resource limits · health checks · multi-stage builds · no build tools in prod
Zero-Trust Security

Dockerize-Everything

In plain terms: Six connected services, each locked down individually — so if one is compromised, the breach can't spread to the database or to other services.

Problem: Running six interdependent services with proper security, resource isolation, and startup ordering is not a dev problem — it is a production problem.

Decision: Apply production security patterns from day one — network segmentation, non-root users, multi-stage builds, vulnerability scanning on every build.

⚡ Flask image: 186MB, zero build tools in prod  ·  Trivy scan every build  ·  Every deploy pinned to Git commit
Architecture
Git commit → Trivy scan → two isolated networks (frontend / backend) → 6 services with health checks, resource limits, non-root users. No cross-network traffic unless explicitly permitted.
Failure Scenario
A compromised container in the frontend network cannot reach the database layer. Network segmentation ensures a breach in one service cannot traverse to sensitive data stores.
Key Tradeoff
Multi-stage builds increase build complexity but eliminate an entire class of supply-chain vulnerabilities. Build tools never reach the production image.
Result
Flask production image at 186MB. No build tools, no root access, no unscanned dependencies. Every deployment traceable to an exact Git commit and a clean Trivy report.

REAL SYSTEMS.
MEASURED RESULTS.

20–46s
Node Recovery
Simulated failures, 3-node cluster, measured across multiple runs
32s
Automated Rollback
Bad deployment detected and rolled back — no human intervention
Seconds
Drift Reconciliation
Manual cluster changes detected and auto-corrected by ArgoCD
Zero
Static Credentials
Vault issues credentials dynamically — eliminates leak-class incidents
36
Alert Rules
Focused on SLO-impacting failures — reduces alert fatigue, not increases it
100%
Cost Visibility
Per-service cost attribution from day one — no surprise cloud bills

WATCH IT WORK.
NOT JUST READ ABOUT IT.

This is the auto-healing Kubernetes platform running live. A node fails. The platform detects it, evicts workloads, reschedules them — all within 46 seconds. No manual intervention. No alert fatigue. Just recovery.

Watch the Recovery
Click to play · ~1 min
Live recording — Auto-Healing Kubernetes Platform  ·  Node failure to full recovery in under 46 seconds

BUILDING RELIABLE PLATFORMS THROUGH AUTOMATION, OBSERVABILITY, AND FAILURE ENGINEERING.

Open to remote contract engagements. Response within 24 hours.

Platform Engineering
Kubernetes Infrastructure
GitOps & Progressive Delivery
Reliability Engineering
Cloud Cost Optimization
Available for remote contracts —US · Canada · UK · Germany · Netherlands