Nguyen Le Phong

Blog

Writing from building software and leading teams: architecture, AI in everyday engineering, and how teams actually ship. Some are short essays, some are long guides. Career and life reflections live in Notes.

Latest articles · Page 20 of 23

Perspectives & Field Notes

Hoang Nguu Son: Reach the Summit, Come Down, Keep Going

A day on Hoang Nguu Son, 972 m, with more than 150 Zalo teammates: a few minutes of wondering whether I could keep up, sunny slopes, checkpoint pauses, and the moment we reached the summit. I carried that feeling back into work as a friendly, practical reminder: when things get hard, adjust the pace and keep moving; to climb the next mountain, first come down from the current one, clear what is not working, and prepare honestly for the next challenge.

10 min read
Source & Architecture

Scaling the Database: Indexes, Read Replicas, Caching, and Sharding — In That Order

The database is almost always the first thing to buckle under growth — and the first thing engineers over-engineer in a panic. A no-hype ladder for scaling the data layer: why you measure and add an index before touching hardware, how read replicas exploit the read/write asymmetry (and the replication-lag trap they bring), where caching helps and why invalidation is the hard part, and when you finally reach for partitioning and sharding — the one decision that is genuinely hard to undo.

14 min read
Source & Architecture

You Can't Fix What You Can't See: Logs, Metrics, Traces, and SLOs at Scale

In a monolith, debugging was almost cosy — one log file, one process, one place the truth lived. Distributed systems quietly took that away: one request now fans out across a dozen services, and when it breaks there is no single log to read. A no-hype guide to seeing your system at scale: the three pillars (metrics, logs, traces) and the question each one answers, why a single propagated trace ID is the highest-leverage habit you can adopt, how SLOs turn reliability into an error budget you can spend, and how to alert on symptoms so on-call doesn't burn out.

14 min read
Source & Architecture

Who Owns the Data? Database-per-Service, Sagas, and Eventual Consistency Without Tears

Splitting code is the easy half — splitting data is where distributed systems humble you. A practical guide to owning data across services: why a shared database is a distributed monolith, the trade from ACID to eventual consistency, the dual-write bug and the outbox that fixes it, sagas with compensating actions, and when CQRS and event sourcing are worth their lifetime cost.

13 min read
Source & Architecture

The Distributed-Systems Tax, Paid: Timeouts, Retries, Circuit Breakers, and Idempotency

The moment a call leaves your process it can be slow, fail, or happen twice — and that is the normal case, not the exception. The resilience toolkit, explained plainly: why timeouts come first, how retries become a self-inflicted DDoS without backoff and jitter, why idempotency is the price of retrying, and how circuit breakers, bulkheads, graceful degradation, and observability keep one bad dependency from taking down everything.

13 min read
AI & The Future

Your Fear of AI Is the Size of Your Ambition: Why It’s Time to Aim Dramatically Bigger

Two people can look at the same AI breakthrough and feel opposite things — terror or fuel — and the difference reveals something uncomfortable: our fear of the future is roughly the size of our ambition. If your plan is to keep doing exactly what you do, a machine that does it cheaper is frightening. If your plan is to build something dramatically bigger, it’s the best news you’ve ever gotten. This is a clear, energising case for retiring “don’t boil the ocean,” trading the 1.05x present for the 10x future, and why — through ephemeralization and the Jevons paradox — raising your ambitions tends to create more, not less.

11 min read
Engineering Culture

From Software Engineer to Technical Manager: The Counterintuitive Things You Learn

Moving from Software Engineer to Technical Manager isn’t a bigger version of the same job — it’s a quiet rewrite of the very habits that made you good at the last one. Step back from the IDE to see architecture, people, and process, and three surprising truths come into focus: code is an asset and a liability at once, your value shifts from addition to multiplication, and delegation is simple to say but genuinely hard to let go of. A practical, honest reflection for senior engineers eyeing the lead role — and for new managers still reaching for the keyboard.

12 min read