Building backend systems and the infrastructure that keeps them running.
4+ years building, deploying, and operating production systems: APIs and microservices, AWS and Kubernetes infrastructure, CI/CD pipelines, and the observability that keeps them reliable.
I own the full lifecycle of a production system, end to end.
What I actually work on
Backend Systems
I design and build the services underneath the product — REST APIs, background workers, and the data models they depend on — using Node.js/NestJS, Laravel, and FastAPI/Django depending on what the system needs.
Cloud Infrastructure
I provision and manage the AWS resources that run those services — ECS/EKS, EC2, RDS, S3 — and define all of it as Terraform so environments are reproducible instead of hand-configured.
Platform Engineering
I build the deployment and tooling layer engineers actually work against day to day: CI/CD pipelines, container standards, and the shared infrastructure that lets a team ship without re-solving the same problems each time.
Distributed Systems
I've split monoliths into services that communicate through API gateways and message queues, and dealt with the real consequences — race conditions, duplicate execution, and failure isolation across service boundaries.
DevOps & Automation
I set up CI/CD with GitHub Actions, automate repeatable infrastructure tasks with Terraform and Ansible, and remove manual steps from deployment wherever they create risk.
Observability
I instrument systems with centralized logging and metrics — SigNoz, CloudWatch, Grafana, Loki/Promtail — so production problems get surfaced and diagnosed instead of discovered by users first.
Systems I've built and operated
Each project below is what I built, why, and what changed as a result.
Vine Mobility
Designed and provisioned the production AWS infrastructure for a microservice-based mobility platform, from first deploy through cost and reliability hardening.
Obscura
A microservice platform of around five services, each in a different language/framework, communicating through a shared API gateway.
Auvraai
End-to-end infrastructure and deployment setup for a FastAPI backend paired with a modern frontend, from local dev parity to production hosting.
Principles I build production systems around
Build for failure, not just the happy path
External dependencies will eventually fail or time out. Retries with backoff, circuit breakers, and async fallbacks contain the damage instead of letting it cascade.
Infrastructure as code, no exceptions
Manual console changes create drift and deployments nobody can reproduce. Every environment should be defined in version-controlled Terraform, not tribal knowledge.
Observe before you optimize
Don't guess at bottlenecks. Logs, metrics, and tracing tell you what's actually slow before you start changing code.
Cost is an engineering constraint, not finance's problem
Idle compute and unindexed queries are bugs with a dollar sign attached. Efficient infrastructure is part of the job, not an afterthought.
How I think about a production system
A simplified view of the request path through a typical system I build — click a layer for detail.
Ingress & routing layer
Terminates TLS, routes external traffic to the right internal service, and rate-limits so one noisy client can't degrade everyone else.
Problems I've debugged in production
Real issues from database concurrency, distributed job execution, and third-party integrations.
Duplicate job execution across scaled instances
Race conditions & distributed locksDuplicate email notifications and double payment execution at the top of every hour.
Cron triggers lived inside the application container. Scaling from 1 to 5 replicas meant every instance independently fired the same scheduled job at the same time.
Moved cron execution into a single isolated worker and wrapped job execution in a Redis-backed distributed lock with atomic TTL acquisition (SET key value NX PX), so only one instance ever runs a given job.
Database connection pool exhaustion under load
Database performance & query optimizationAPI endpoints returning 500s with 'remaining connection slots are reserved' during peak traffic.
Unindexed polymorphic queries were triggering full table scans, holding connections open while waiting on disk I/O.
Added compound indexes on the hot query paths, introduced PgBouncer for connection pooling, and fixed the underlying N+1 queries with targeted eager-loading.
Silent payment webhook failures
Integration & resilienceCustomers debited by the payment provider but marked unpaid in our system, leading to support escalations.
Webhook handlers processed payloads synchronously and the provider timed out the request after a few seconds, so the acknowledgment never landed before the connection dropped.
Changed the webhook endpoint to acknowledge immediately, then process the payload asynchronously off a queue with idempotent handlers so retried deliveries can't double-apply a payment.
From backend development to platform engineering
Backend Engineer — Bankit Microfinance bank
Prior roleBuilt and maintained backend systems handling financial transactions and bill/payment processing.
- —Worked extensively with Laravel, Node.js/NestJS, PostgreSQL, MySQL, and Redis, integrating third-party payment APIs.
- —Diagnosed and fixed production issues including race conditions, duplicate cron execution across instances, database query bottlenecks, and silent webhook failures.
- —Handled Kubernetes deployment issues, SSL/Nginx configuration, and persistent volume/storage problems in production.
Backend & Systems Engineer — Obscura
Built a five-service polyglot microservice platform behind a shared API gateway.
- —Designed inter-service communication and API gateway routing across services written in different languages.
- —Used Redis for shared state and event broadcasting between services.
- —Containerized every service for independent deployment and scaling.
Founding DevOps Engineer — Vine Mobility
Part-timeOwned cloud infrastructure end to end for a microservice-based mobility platform.
- —Designed and provisioned AWS infrastructure with Terraform as the single source of truth.
- —Containerized backend services and built CI/CD pipelines for deployment.
- —Set up monitoring and logging, and cut cloud credit consumption by roughly 80% through infrastructure optimization.
Platform Engineer — Auvraai
Built the deployment infrastructure for a FastAPI backend and its frontend.
- —Containerized the FastAPI backend and defined infrastructure in Terraform.
- —Hosted the frontend on AWS Amplify with a defined PostgreSQL migration path.
- —Established environment parity between staging and production.
Some things I've shared publicly
A few notes on backend, cloud, and DevOps work, posted outside this site.
“I had one of those production moments this week that made me appreciate distributed systems a little more.”
Read on LinkedIn“One question I get asked a lot is: 'Why do you use AWS instead of DigitalOcean?'”
Read on LinkedIn“Sometimes the reason I procrastinate learning a technology isn’t because it’s difficult, it’s because I’ve lost the mental model.”
Read on LinkedInNotes on the systems I build
Short write-ups on production problems I've actually run into — root causes, fixes, and what I took away from them.
I build backend systems and the infrastructure that keeps them running.
I started as a backend engineer — building APIs, services, and the databases behind them with Laravel, Node.js, and NestJS. Working on systems that processed real financial transactions pushed me past just writing code: I had to understand what happened to that code once it was deployed — how it scaled, how it failed, and why.
That led me into cloud infrastructure and DevOps: provisioning AWS with Terraform, containerizing services with Docker, running them on Kubernetes and ECS, and building the CI/CD pipelines that ship them. Along the way I picked up the observability side too — logging, metrics, and monitoring — because you can't operate what you can't see.
Today I think about software across its whole lifecycle: from the code itself, through containers and infrastructure, to deployment, observability, and the ongoing work of keeping a system reliable and cost-efficient in production.
Let's talk about your systems.
Open to backend, cloud, DevOps, and platform engineering roles, as well as infrastructure consulting.