Writing & Notes

Why a trading platform can't ship the free TradingView widget, and the full pipeline from tick to candle: a custom datafeed, a Web Worker fetching tens of thousands of candles, a backend cooking candles in Node memory — then both sides optimizing together around one insight: a closed candle is immutable.

What tRPC actually is, and why a NestJS + React monorepo dropped every REST controller to run on it: the express adapter, a JWT-authenticated context, a procedure chain, router factories co-located with services, React Query hooks generated straight from router files — and the price you pay.

I've sat on both sides of the Tech Lead interview table: people usually fail the leadership & behavioral round not for lack of skill, but because their stories lack context and lack the cost. Covers telling STAR stories with numbers, ADRs and trade-offs, handling disagreement, managing tech debt, mentoring mid to senior, code review culture, negotiating scope, incident ownership, and the questions worth asking back.

The frontend system design round for a Lead role: when NOT to use micro-frontends, Module Federation vs iframe vs route-based, monorepo with build cache, design system governance, data fetching strategy, strangler migration and observability — through a case of 6 teams, a 25-minute build and releases stuck in a queue.

Session or JWT, refresh token rotation, cookie flags, CSRF, XSS and CSP, OAuth2/OIDC with PKCE, the BFF pattern: seven Auth & Security questions I often see in the Senior Fullstack round, with Go and React examples.

What is the browser actually doing underneath the framework? Six groups of browser-internals questions I often see in the Senior Frontend round: the critical rendering path, layout/paint/composite, layout thrashing, streaming SSR and hydration, memory leaks, debugging with DevTools, and optimizing INP.

The Senior-level TypeScript round doesn't ask for definitions: constrained generics, conditional/mapped/template literal types, infer, narrowing and discriminated unions, satisfies, type-safe API clients and forms, and how to avoid any without giving up pragmatism.

Every Next.js feature was born to solve one specific problem. This post follows that order: CSR waterfall → what's wrong, classic SSR → what's wrong, streaming → what's wrong, RSC → what's wrong. It starts from the foundational question many people skip: why can React do SSR when react-dom-server contains no Fiber at all?

What the mid-level JavaScript round actually asks: event loop log order (macrotask/microtask), closures, this, prototypes, async/await and Promise combinators — with guess-the-output exercises, worked answers, and why candidates who 'know' it still fail.

On React 19: follow the whole path from calling setState to a pixel changing color. Fiber is the unit of work, Lanes is a 31-bit priority system, the Scheduler slices the main thread every 5ms. Plus hooks seen from the inside, the three phases of commit, and what React 19 actually changes at this layer.

The real problem SSR solves is a round-trip problem. We walk through the CSR waterfall, then the actual bytes on the wire when you stream — <!--$?-->, template B:0, $RC() — then the second render few people count: hydration. Plus a table for choosing CSR/SSR/streaming/SSG/ISR/PPR by what each one really costs.

CPU utilization is only 40% and p99 latency still blows up: the cgroup CFS quota gets drained in the first few milliseconds of each period. GOMAXPROCS, how throttling works, and how Go 1.25 reads the container CPU limit on its own.

How long does an event take to get from a Go goroutine to a React component, and where does it get stuck? A write-up of a one-way SSE case: why I picked it over WebSocket, how a bounded channel keeps a slow client from taking the server down, and how to keep both ends of the contract from drifting apart.

Ten semantic traps in Go that mid-level engineers often get wrong: typed nil in interfaces, slice aliasing, loop variables, random select, map races, goroutine leaks, and how each one blows up in production.

Senior-round React deep technical interviews tend to circle the same ten questions: setState and batching, stale closures, useEffect, fetch race conditions, useMemo, useCallback, useRef, context, concurrent rendering, with answers derived from the mental model instead of memorized APIs.

A distributed rate limiter in Go, told as a system design interview: what to ask before drawing anything, why token bucket beats fixed window, an atomic Lua script on Redis instead of read-then-write, a two-tier architecture that cuts round trips, and a few real production traps.

React's O(n) reconciliation heuristic: why a key is identity and not a way to silence a warning, when state gets attached to the wrong element, and how to measure re-render cost before sprinkling memo across the codebase.

A look at the internals of three generations of build tools: webpack's make-seal-emit lifecycle, Vite's transform pipeline and Environment API, the Rust-JavaScript bridge inside Rspack, and how Rsbuild layers plugins on top, plus how to measure without fooling yourself.

One tour booking touches five different systems, and one of them is a third-party API nobody controls. Moving to a saga with compensation, writing the steps with Medusa v2's workflow engine, and the most painful part: idempotency.

Senior fullstack interviews keep digging into three things: Goroutines, Channels and Mutexes in Go; system design questions; and the behavioral round. Here is how I answer them, with one STAR story that comes with real numbers.

Inside J.A.R.V.I.S.: a ReAct runtime written in Go 1.25+, multi-agent routing before the LLM call, parallel tool execution with errgroup, 3-tier memory (Vector + Graph + Redis), and SSE streaming through a Fastify gateway.

A tour and ticket storefront needs both SEO and fast loads. How I split Server and Client Components, and how Suspense streams the slowest part of the page: the price block converted at the live exchange rate.

One abstraction layer for Stripe, Adyen, LINE Pay, KakaoPay and Toss: add a new payment provider without touching the core order logic. Plus webhook idempotency and a reconciliation job that runs every 15 minutes.

3:07 AM, a p99 latency alert above 15s: two transactions locked in opposite order and deadlocked on PostgreSQL, then the client retried after 3 seconds and double-charged. How we fixed it with an Idempotency-Key and lock ordering by account_id.

Shipping on time is necessary, but it isn't enough. A 4-axis checklist I use to grade myself (Technical Depth, System Thinking, Ownership & Communication, Mentorship), with real examples from Bolt Technologies, Cognisian and SmileViet.

The system design question I get asked most in interviews is also the problem I work on every day: booking tours and flights through a flash sale without overselling. A 4-step framework, a seat lock with a TTL, and idempotency keys.

Reviews of a standing desk, a color-accurate monitor, an ergonomic mechanical keyboard, and the small habits that keep your energy sustainable.

An incident where tour prices showed wrong to customers after an admin updated them through the CMS, and how I redesigned cache invalidation to be event-driven instead of relying on TTL alone.

Two payment webhooks arrived almost simultaneously and a booking got charged twice in the ledger. How I traced it through logs, reproduced it with Promise.all, then pushed the constraint down into the database with a unique constraint and an advisory lock.

A healthcare dashboard with ~150 charts queried Postgres directly, and every chart took 1.5 seconds. After moving to StarRocks with materialized views partitioned by month, p95 dropped to ~250ms, an 80%+ cut in latency.

How many pieces does a Senior Engineer's day get torn into? How I block out deep work hours, where context switching eats your energy, and the burnout signs I track in myself.

Cursor for writing code, Claude Code for well-scoped tasks, Gemini CLI for huge context, plus the lines I draw for myself: what I let AI automate, and where I keep hands-on control of business logic.

When the socket pushes 20,000+ ticks per second, the main thread dies before the chart does. How we moved candle aggregation and indicators into a Web Worker, used transferable objects to avoid copying data, and used double-buffering to prevent tearing during render.

Why I picked Radix Primitives as the foundation for an internal component library, how Shadcn/UI generates code straight into your repo, and how an admin dashboard and a storefront each override --primary and --radius through CSS variables. Plus dark mode and versioning when apps don't upgrade at the same time.

Three causes of unnecessary re-renders, how to measure Core Web Vitals (LCP/INP/CLS) with both lab data and field data, and when useMemo/useCallback actually help — with before/after numbers from a dashboard with ~150 charts.

When many people write Tailwind in one repo, the UI starts to drift: everyone picks a slightly different gray, a slightly different padding value. How we pulled it back: centralized design tokens, limits on arbitrary values, and controlled @apply, so the interface stays consistent as you scale.