Henry
Lee

Backend Team Lead

I build the backend systems a high-concurrency transaction platform runs on — and lead the team that keeps them correct at scale.

Hi — I'm Henry. I take backend platforms from a legacy monolith to contract-first gRPC microservices — the systems behind millions of daily transactions — and I lead the team that runs them.

7 years engineer → senior → lead

Millions of transactions/day, audited every transaction, checked and logged

50k → 400k+ users users never noticed — which was the job

Get in touch See the work Resume (PDF)

Featured Work

Case 01

The transaction backbone

Every financial transaction on the platform passes through it — I took it from a legacy monolith to a contract-first service.

monolith → microservices idempotent by construction self-serve SDK

Millions of transactions a day, and if it goes down the whole platform stops. I rebuilt it from a legacy monolith onto gRPC + durable workflows — idempotency by construction, so a retry can only return the record it already made — and made integration a self-serve SDK that cut new-type onboarding from 30–60 minutes to two.

Read the case study →

Case 02

Scaling a platform, live

50k → 400k+ users and still climbing — the job was making sure nobody noticed.

measured before tuning replaced live every step revertible

As the platform grew, ID generation, notification fan-out and blocking scans each hit the old architecture's limits — an outage stops every transaction. I measured where the time actually went, then replaced each mechanism in production: no downtime, users online, every step revertible.

Read the case study →

Case 03

Real-time support platform — from zero to clean handoff

The first production service on a new stack — every pattern I set became the template others copied.

first on the new stack buy the base, build the moat solo → team → clean handoff

AI-assisted support with human takeover, built solo on a stack nobody had shipped to production yet. I bought the messaging base and self-built only the differentiators — routing, AI-to-human handoff, back-office — grew it to a two-person team, and handed it off clean. Being the pilot meant my patterns became the template every later service copied.

Read the case study →

More work

All seven systems →

Millions transactions a day, audited

400k+ daily users, from 50k (climbing)

5 person team, two stacks

5 partner teams coordinated per project · 6 domains, two stacks · 80% coverage gate, enforced · weekly release train, full regression · 16 features shipped through my AI pipeline

Systems, at altitude

Beyond any single feature — the decomposition, the platform, and the discipline to run it.

Decomposed a legacy monolith into gRPC microservices.

Growth forced the rewrite — millions of transactions a day, ~1,000/s and still climbing past what the old architecture could hold. I led the migration of the platform's most critical flows onto a new NestJS/gRPC + Temporal stack: framework first, dead code retired on the way, the cutover carried by the SDK with endpoint-level fallback. Migration as modernization, with a rollback built into every step.

Built the contract-first platform the team ships on.

Proto-first by contract: one .proto generates the gRPC types the SDK and every service share, so integration is one import with zero boilerplate. Adding a new request type went from a 30–60-minute, person-dependent process to a two-minute self-serve form — pull request, publish, semantic versioning, changelog, notify. 100+ published versions; 200+ request types run through one base workflow. Developer enablement, not just a library.

Ran it with production-grade observability.

What I watch every morning: queue backlog, workflow retries, database load, slow queries, CPU/memory spikes and leaks — on Grafana, with Aliyun SLS for log-based alerting and incident triage, OpenTelemetry traces and Prometheus metrics underneath. Graceful shutdown is a non-negotiable readiness gate — it came out of a real incident. Index first, cache second: queries that timed out on a single day of data now scan a 30-day window.

Proof — run the designs

Don't take my word for it — these are live, interactive rebuilds of the designs above. Break them yourself.

live demo 01

Retry Storm

Hammer one transaction with retries — the idempotency design refuses to execute it twice.

Play the design → live demo 02

Dispatch Floor

Watch the routing queue pick the next agent — status first, load second, longest wait breaks the tie.

Play the design → live demo 03

Live GitHub

This site's own repository activity, streamed straight from the GitHub API — the shipping never stopped.

See it live →

How I Work

Principles first, tasks second. The systems are half the job — the other half is building the people who build them.

Price the risk before pricing the work.

The first question is never "how long will it take" — it's "what breaks if this is wrong, and who feels it?" Failure cost decides engineering rigor.

Grow owners, not task-takers.

Each engineer owns a domain end-to-end — requirements negotiation with business included.

Command the incident, then make it pay rent.

Roll back first, diagnose second — then the incident pays: a playbook, a release rule, a report upward. Our risk-alerting pipeline was born from a single missed charge.

Design for the next change, not this delivery.

What business will tune later becomes configuration, not code — a feature request becomes an ops change, not a deploy.

Decompose by ownership, not by ticket.

Contracts split before anyone writes code — a cross-cutting feature once landed across five repositories in one day.

Decide with evidence, commit with a rollback.

Big choices get benchmarks and proofs of concept — one analytics-store evaluation ran 30 queries × 50 rounds across three engines before we committed.

Turn work into leverage.

Anything done twice becomes a tool — integration SDKs, incident playbooks, an AI diagnosis bot the whole team runs.

Calibrate the challenge.

Stretch without drowning — I watch where people stall and nudge; I don't grab the keyboard.

Pair temperaments, not just skills.

A meticulous slow-mover next to a fast pusher who gets careless — tuned like any other system, re-tuned when they drift.

Keep a floating seat.

One engineer goes wherever the pressure is — that seat is how I grew up, so I built it into the team on purpose.

Trade one deadline for the next ten.

Build the base once and the next ten requests become configuration — a "no" always ships with its reason and its alternative.

About me

Seven years ago I joined a high-traffic transaction platform as a full-stack dev. It grew — and went down a few times along the way. I was the firefighter, then the one hand-picked to pioneer a new stack, then the owner of the platform's most critical module — and now I lead the team that runs its core.

I care about two things: systems that don't drop a transaction, and engineers who outgrow the tasks I give them.

Now: raising a self-hosted Hermes agent (it maintains this very site), going deeper on Rust and stream processing, and writing down what production taught me.

experienceA high-concurrency transaction platform, 2019 → present — engineer to Backend Team Lead. Where this happened →

core stackTypeScript · NestJS · gRPC · MongoDB · Redis · Temporal · Pulsar — full tiers →