Full stack engineer
Mumbai, India
I engineer solutions at scale — the services, the data underneath them and the interfaces on top, for platforms that other teams build on.
Scroll
I build things that have to work at scale — and I build the whole of them. Service, schema, pipeline, and the interface somebody actually uses.
Seven years, four banks, most of it on platforms other teams build on. Spring Boot and Python services, Kafka through the middle, Postgres and Redis holding state, Kubernetes underneath. The thread is scale: designs that keep their shape as load, teams and scope grow.
I like problems that span layers, because that is where the good decisions live. A slow page is sometimes a frontend problem and sometimes a missing index. Being able to follow the thread the whole way is most of the job.
A complex system that works is invariably found to have evolved from a simple system that workedEvery platform I have worked on that holds up today started as something small that already worked. Scale is earned, not designed in one sitting — the systems that tried to arrive complete are the ones still being rewritten.
Gall’s law — the reason I ship the small version first
III — Four rules
Conway’s Game of Life. Every square looks at its eight neighbours and obeys the same four rules, forever. Nobody wrote the gliders, the oscillators or the gun currently firing — they are what the rules do.
Three neighbours → born
Two or three → lives on
Fewer than two → dies
More than three → dies
Each pair is one step: the square outlined on the left, and what the rules make of it on the right. That is the entire specification.
SDE 2 — core trading platforms, Asset Management
Modernizing a platform that cannot stop trading.
Services, data model and the screens the desk works in, replaced piece by piece — the swap invisible to the people using it.
Real capability every quarter while the system underneath changes — a desk should never be able to tell which quarter its screen started talking to a new service.
Software Engineer BA4 — platform engineering, end to end
API's replaced the tools that scheduled an entire estate.
Highly available Spring Boot, a Redis cache-aside authorization layer, breakers on the edges — from a handful of operators to the way everything is scheduled.
Alongside it, a schema-driven enrichment engine for enterprise alert traffic, and credential rotation, maintenance suppression and onboarding turned from manual rituals into products with APIs.
DevOps Engineer — delivery, containers, configuration as code
Deployment stopped being an event.
Kubernetes and OpenShift with room to scale through peak, environments in Ansible, secrets out of human hands.
Quality and security gates moved into the pipeline ahead of review, so shipping became an ordinary afternoon instead of an event that needed a plan.
Senior Analyst — where the full stack habit started
Both ends of the wire, usually the same afternoon.
Django and Flask services with the React and Angular front ends that consumed them, written by the same person.
It taught me to design the API around the thing someone eventually has to look at — a backend nobody can see is a backend nobody can fix.
V — Design review
Keep scrolling
Total failure is the case everyone designs for. Partial degradation is the one that takes the system with it — a dependency at four seconds instead of forty milliseconds, and every caller upstream holding a thread open waiting for it.
Every split-brain argument is this question wearing a costume. Decide which side may keep serving stale data during a partition, write it down, and stop pretending both halves can be authoritative.
Not "does it scale" — that question has no answer. Which specific thing gives first: a query plan that flips, a lock everyone queues behind, or the one partition all the hot keys hash to.
If the answer involves calling you, it is not finished. What signal fires, what the runbook says to do about it, and where the switch is that turns the feature off without a deploy.
Schemas and public APIs are one-way doors; almost everything else can be revisited next quarter. Knowing which kind of door you are walking through is most of the design review.
Not the dashboard nobody opens. The specific signal, the threshold that trips it, and the person it wakes — decided now, while it is cheap, rather than during the incident.
VI — The stack
Ordered the way a request travels, because that is the order I think in. I have shipped production work at every one of these layers, and the interesting problems almost always live at the seams between two of them.
What a person actually touches
Where the rules live
The part that outlives the code
How the pieces tell each other things
Getting it there, repeatedly
What I reach for before the code
VII — Writing