Senior Backend Engineer | Distributed Systems | Scalable APIs | Cloud-Native
4+ years in backend engineering. A system-focused engineer designing scalable backend platforms, tuning performance, and hardening reliability under real production load.
interactive architecture
A request path should feel coherent before it feels impressive. Hover a service to inspect its role. Click the canvas to replay the lifecycle.
reading the system
Core services sit closest to the runtime center. Edge and infra layers stay wider, while async work moves on slower orbits to emphasize decoupling. Hover to inspect a service. Click anywhere to restart the request flow.
experience stream
High-traffic transactional systems need one source of truth. This incident was contained by moving pricing correctness into deterministic backend validation.
Problem
Inconsistent pricing validation between standard and affiliate flows.
Root Cause
A validation gap existed between entry points before final transaction handling.
Solution
Deterministic backend validation made pricing rules authoritative server-side.
Impact
Prevented revenue leakage and stabilized trust in transactional pricing.
architecture decisions
Senior backend work is judgment under pressure. Pick a decision to inspect the constraint, tradeoff, and production impact behind it.
active decision
ADR-001 / accepted
Context
High-concurrency bookings were competing for the same inventory slot.
Decision
Guard the allocation path with Redis distributed locks and idempotency checks.
Tradeoff
Adds coordination overhead, but keeps correctness explicit under load.
Impact
Eliminated double-booking risk and protected 1000+ concurrent request flows.
philosophy
I don't just write code. I design systems that scale.
The point of principles is not purity. They help me keep systems legible, reduce failure surface area, and make change cheaper when the product inevitably shifts.
Keep It Simple, Stupid
If it needs explaining, it's already too complex.
I bias toward straightforward flows, obvious naming, and fewer moving parts so a teammate can debug production without a guided tour.
in practice
One clear service boundary beats three clever abstractions.
Don't Repeat Yourself
Duplication is a bug waiting to scale.
When the same rule shows up twice, I look for the missing contract. Shared logic belongs in one place with one owner.
in practice
Centralize pricing validation once, then make every entry point use it.
You Aren't Gonna Need It
Build for now. Not for imaginary futures.
I build for today's load, today's product, and today's constraints. Premature flexibility usually turns into permanent maintenance.
in practice
Ship the booking path first. Add the plugin system when a real second use case exists.
Single Responsibility, Open/Closed, Liskov, Interface Segregation, Dependency Inversion
Structure scales. Chaos doesn't.
Good structure keeps change local. The goal isn't ceremony, it's components and services that can evolve without collateral damage.
in practice
A card renders state. Data shapes live in lib. Motion stays at the edge.
system modules
Problem
Peak demand caused competing writes for the same inventory slots.
Solution
A lock-first transactional path using Redis and idempotent booking commands.
Impact
100% slot allocation accuracy with 1000+ concurrent requests.
Problem
High-volume read paths amplified slow queries and downstream waits.
Solution
Query tuning, cache placement, and route-level response shaping.
Impact
40% lower API latency and around 70% less database load.
Problem
Background work leaked into synchronous request paths.
Solution
Kafka-backed async workers with retries, observability, and CI/CD gates.
Impact
Reliability improved by 25% with cleaner failure isolation.
mini game
Debug logs are saturating IO during peak traffic.
objective: Reduce noise before adding capacity.
incident scorecard
0
solved
0
crashes
0
streak
0
best
0
hints used
0
latency
520ms
error rate
22%
throughput
365rps
applied runbook
no actions applied yet
recruiter mode
secure access terminal