Writing

Eight years of production code, from medical school to senior engineer. Not a lessons-learned list. More honest than that.

I picked it up for a specific project. I kept using it because it's genuinely good.

A small collection of hooks that I've written once and used on every project since.

i18n is the easy part. RTL layout, locale-specific formatting, and building for users who have never used a smartphone before: that's where it gets interesting.

Express is flexible. NestJS is opinionated. At a certain team size, opinionated wins.

JSI, Fabric, TurboModules. Here's what actually changed after migrating a production app.

Server Components aren't SSR. The distinction matters more than most explanations suggest.

Most P2P JavaScript tutorials use WebRTC. The Holepunch stack is different and more capable.

Most tutorials show you all the services. Experience narrows it down fast.

Not everything needs a test. Here's how I decide what to test, how to test it, and when to skip it.

The testing toolchain is fragmented. Here's the setup that's worked across multiple projects.

Go is different in ways that aren't obvious from the syntax. The concurrency model took the longest to internalise.

Suspense has been "coming soon" for data fetching for years. Here's where it actually stands and how I use it today.

Connecting a hospital to an available interpreter in under 30 seconds, reliably, at 3am. Here's how the system works.

Both are message systems. They solve different problems and the overlap is smaller than the marketing suggests.

Every React app needs error boundaries. Most implementations miss the parts that matter in production.

In markets where connectivity is unreliable, offline-first isn't a feature. It's a requirement.

There's a long list of things you can try. These are the ones that made a measurable difference.

React is fast by default. When it isn't, here's how I find and fix the problem.

Small images, non-root users, multi-stage builds, graceful shutdowns. Here's the Dockerfile pattern I've converged on.

React Hook Form and Formik are good tools. You don't always need them.

The real question isn't relational vs document. It's about your query patterns and how much your schema will change.

Audits find what you missed. Understanding the patterns means missing less.

We migrated a 40-page Next.js app to the App Router. It took three weeks. Here's what went smoothly and what didn't.

The docs show you what's possible. Experience shows you what's practical.

Socket.io gets you started. It doesn't handle reconnections, horizontal scaling, or graceful degradation without additional work.

I started coding in medical school, shipped production software by third year, and worked full-time as an engineer throughout. The path was never linear.

Not every pattern from the docs is worth using. These are the ones that have survived contact with real codebases.

Android-specific bugs are their own category of pain. These are the tools and approaches that actually help.

We did this while the app was in active development. It was rough for a week and smooth after that.

Most explanations stop at "it's non-blocking I/O." Here's what I wish someone had told me when I started hitting real concurrency issues.

useState works until it doesn't. Here's how I think about when to reach for something else, and what to reach for.

The Solidity docs are fine. The problem is everything around the contract: gas estimation, deployment scripts, and why your tests pass locally but the contract behaves differently on testnet.

The documentation gets you to Hello World. It doesn't tell you about the four days you'll spend fighting Gradle.