Diving deep into low-level mechanics to uncover the WHY behind the magic
I focus on scalable backend systems and low-level fundamentals — transitioning from a career in Equity Derivatives Trading.
- My Edge: Continuous, deep-dive learning. In a sea of surface-level frameworks, I go straight to the fundamentals (Linux internals, API design, SOLID principles, MCP security) so I can architect, build, and ship independently.
- Engineering Philosophy: Frameworks come and go, but system mechanics are forever.
"Junior comprehends, Senior simplifies."
Rather than listing static tools, here are the core engineering vectors I actively architect, build, and optimize:
- What I build: Container orchestrators, worker node heartbeat state machines, and concurrency queues operating directly on raw system calls.
- Under the hood: Direct HTTP control planes interacting with the Docker Engine API, Linux
/procprocess telemetry, and gRPC/Protobuf inter-service communication. - Stack in Action:
Go (Golang)·Docker Engine API·gRPC / Protobuf·Ubuntu Linux Internals
| Domain | What I'm Building Toward |
|---|---|
| 🐹 Go (Golang) | High-performance backend services — concurrency primitives, stdlib depth, production-grade CLI tools |
| ☸️ Kubernetes | Graduating AI agent workloads from local Docker to resilient, auto-scaling K8s clusters |
| 🤖 MCP & Agentic Systems | Custom MCP servers that bridge LLMs with local tools and external APIs securely |
| 🐧 System Fundamentals | Linux internals, Bash automation, and OS-level performance tuning on Ubuntu |
Go · Docker SDK · Concurrency · Distributed Systems
A container orchestrator built from scratch in Go to understand how Kubernetes-style systems work under the hood instead of just operating them. Tasks are submitted to a manager, placed on workers by a pluggable scheduler, and run as Docker containers via the Docker SDK. Each node reports resource stats back so scheduling decisions are based on real capacity.
Key engineering highlights:
- Layered architecture: Separate packages for
task,worker,manager,scheduler,node, andstats, each with a single responsibility and clear boundaries. - Task lifecycle management: Explicit state transitions for containers (schedule → run → stop) driven through the Docker SDK.
- Pluggable scheduling: Scheduler logic is decoupled from the manager so placement strategies can be swapped without touching the rest of the system.
- Resource-aware placement: Node stats collection feeds scheduling decisions.
📚 Built while following Build an Orchestrator in Go (From Scratch) (Manning), then extended with custom design decisions.
Express 5 · TypeScript · Zod · JWT · OpenAPI 3.1 · Jest + Supertest
A commerce API (auth, products, orders, payments) built to practice the decisions that separate a demo from a production service. Feature-first modules over a framework-agnostic kernel, with one-way dependencies: routes → controller → service → repository → storage.
Key engineering highlights:
- Idempotent writes: Orders and payments require an
Idempotency-Key. Retries replay the original response instead of charging twice. - Security by design: Other users' orders return
404instead of403so IDs can't be probed, andalg: noneJWTs are rejected. - Centralized error taxonomy: Middleware turns typed
AppErrors into a consistent{code, message, details, requestId}shape correlated with logs. - Money as integer satang: Eliminates floating-point drift across line items and totals.
- Table-driven order state machine: Legal transitions and allowed roles declared as data rather than scattered conditionals.
- Ports & adapters: Services depend on interfaces (gateway, cache, idempotency store) for zero-friction storage swaps.
- Test discipline: 16 suites / 150 tests in under 6s using real in-memory repositories.
📚 Built as part of BorntoDev's Practical API Design course.
I'm open to roles and collaborations at the intersection of Backend Engineering, Systems Infrastructure, and AI Automation Architecture.
