Thoughts & Experiences

A massive misconception among developers is that == checks for value equality while === checks for value and type equality. The accurate explanation is that == allows coercion in the equality comparison and === disallows coercion’

The crutches of your comfort zone may help you walk today, but they are the biggest enemy of your growth.

Everyone sells serverless as ‘pay only for what you use’. But nobody talks about the cognitive overhead: cold starts, DLQ monitoring, distributed tracing across 10 Lambdas, and the fact that debugging is a completely different discipline. The cost moved from infra bills to engineering hours.

Most Angular developers I have mentored treat RxJS like a fancy callback. The shift to thinking in streams — composing, transforming, and timing data flows — takes months. But once it clicks, it changes how you design the entire state layer of an application.

The main concept interfaces offer over types is declaration merging. On the other side, types can do a lot more than interfaces (mapped types, conditional types, etc)

You do not adopt Nx because it is cool. You adopt it when the pain of coordinating shared libraries across separate repos outweighs the simplicity of isolation. The tooling is good, but the real win is making team boundaries explicit through code structure.

When I write a CDK stack, I am not just provisioning resources. I am writing a contract: this is what the system looks like, reproducibly, forever. Drift from that contract is technical debt with real operational consequences. Treat it like application code — review it, test it, version it.

Not in design docs or ADRs (though those matter). The real decisions happen in a 30-minute Slack call where someone says ‘should we really add another service for this?’ and the team actually stops to think. Slow down those conversations. They are cheaper than the refactor later.

We load-tested our middleware at 200 transactions per second for a full hour. Lambda held. But the SQS queue depth graph looked like a heartbeat monitor, and I spent three hours convinced we had a bug. It was just auto-scaling warming up. Observability without context is noise.

Legacy government systems speak SOAP. Modern microservices speak JSON. Building the translator layer in between — with WAF, private API Gateway, and Route 53 inbound resolvers — was the most unglamorous, most impactful work I have ever done. Nobody sees the middleware until it breaks.

The first time a dead-letter queue caught a batch of 3,000 failed messages in production, I felt sick. Then I realised: this is the system working. The DLQ is proof that we planned for failure. Reliability is not the absence of errors — it is knowing where they go.

Writing E2E tests for a TypeScript frontend using Python felt wrong at first. But the QA team owned Python, and the goal was automation, not purity. Two weeks in, we had 60% regression coverage on critical flows. Pragmatism beats elegance when deadlines are real.

We built a Lambda that posts CloudWatch alarm summaries to a Teams channel. Took half a day. It became the first thing the on-call engineer checks in the morning. Sometimes the highest-ROI engineering is a webhook and a well-formatted message.

I keep telling teams that serverless is good for bursty, unpredictable workloads. But where is the real inflection point? At 10,000 RPS? At sustained constant load? I have heard very different answers from very credible people and I still do not have mine.

Code coverage? Cyclomatic complexity? Pull request review time? I have used all of these. None of them capture the thing I actually care about: can a new engineer understand and safely modify this code in six months? I am still looking for a metric that gets close.

EventBridge gives you beautiful decoupling. But ‘who published this event and why did it trigger that Lambda?’ becomes genuinely hard to answer in a post-mortem. I wonder if we are solving coupling by creating complexity of a different kind.

I have seen senior engineers who write brilliant code but cannot bring a junior along. And I have seen others who write mediocre code but ship teams that consistently deliver. Which one is more valuable? I think I know the answer, but it makes me uncomfortable.

Right now AI is great at plumbing — CRUD endpoints, test scaffolding, repetitive config. But the hard decisions — what to build, how services should talk, what to NOT build — still feel very human. I wonder how long that distinction holds.

A thought keeps returning to my mind— a quiet conflict that refuses to settle. If today you were to place a revolver in my hand, perhaps it would awaken a demon within me. But if that same revolver had been given to me before 1947, it might not have awakened a demon, but instead given […]

Maybe destiny was never written. Maybe we are writing it. For generations people have said that everything in life is already written. In India we grow up hearing the phrase: “jo likha hai, wo hoga” — what is written will happen. The idea is comforting.It suggests that somewhere, beyond our understanding, life follows a script […]