Skip to content

Blog

Writing about web development, frontend architecture, and lessons learned from building products at scale.

My Dev Environment in the Vibe Coding Era: Reachable, Not Just Fast 🛰️

When agents do more of the typing, the dev environment stops being the place you sit and becomes a place you can reach. Here’s my setup: Tailscale + SSH + tmux, Claude Code Remote Control, and AnyDesk/TeamViewer as the escape hatch.

toolingaitailscalesshtmuxclaude-codeproductivity

Feature Flags for Frontend: Rollout Safety Without Redeploys

Deploying code and releasing features are two different jobs. Here's the flag system we ran across a fleet of micro-frontends: typed evaluation, sticky targeting, kill switches, and the cleanup discipline that kept it from rotting.

feature-flagsfrontendarchitecturemicro-frontendsreliability

Neovim, QMK, and the Tooling That Eliminated the Mouse for Me ⌨️

A keyboard-first workflow isn’t about being faster—it’s about staying in flow. Here’s the stack (Neovim, QMK, terminal tools, browser keybindings, and a bit of OS glue) that steadily removed small interruptions from my day.

neovimqmktoolingergonomicsproductivity

Micro-frontends at Scale: Module Federation + Shadow DOM Isolation (What Actually Worked)

A pragmatic isolation model for micro-frontends: clean CSS/DOM boundaries with Shadow DOM, shared dependency strategy with Module Federation, common failure modes, and the platform guardrails that made it sustainable.

architecturemicro-frontendsmodule-federationplatformfrontend

CI/CD for Micro-App Fleets: Saving ~1,500 Hours/Year Without Slowing Devs Down

How we standardized pipelines for a micro-app fleet: aggressive (but safe) caching, parallelization, preview environments, and release guardrails-plus the metrics that proved we saved real engineering time.

cicdplatformdevopsmicro-frontendsfrontend

How I Consolidated 12 Internal Portals into One BizOps Platform

A playbook for consolidating fragmented internal tools: how we sliced domains, migrated incrementally without stopping feature work, built shared foundations (design system + platform APIs), and kept stakeholders aligned.

platformarchitecturefrontendproductleadership

Expo/React Native Multi-Tenant Architecture: Shipping Mobile + Web with One Product Brain

A practical multi-tenant architecture for Expo + React Native: typed configuration, feature flags, tenant theming, module boundaries, EAS build/release pipelines, and how to keep one product logic across mobile and web.

react-nativeexpoarchitecturemulti-tenantplatform

Frontend Platform RFCs That Improved DX (Without Blocking Teams)

How lightweight RFCs and decision records helped us ship better defaults-app templates, CI pipelines, and runtime validation boundaries - while keeping teams moving fast.

platformdxprocesstypescriptfrontend

Security Work in the Frontend: PII Masking, Audit Logging, and Permission Surfaces

Frontend security isn’t just hiding buttons. Here’s a threat-model-driven approach: role-based PII masking, leak-proof logs/analytics, explainable permission UX, and audit events you can trust.

securityfrontendprivacyplatformarchitecture

Performance as a Product Feature: Reaching ~95 Lighthouse and Real SEO Gains

Performance isn’t a cleanup task - it’s a product decision. Here’s the workflow we used to move Lighthouse into the ~95 range and improve real-world Core Web Vitals: budgets, profiling, hydration/JS cost, images, and indexing implications.

performanceseoweblighthousefrontend

WebSocket Clients Under Load: Keeping the UI Stable at 1,000+ Messages/Second

Real-time UIs fail in predictable ways under load. Here’s the architecture that kept our app responsive: backpressure, buffering, rAF batching, state separation, reconnect/resume, and instrumentation.

performancewebsocketsreactarchitecturefrontend

TypeScript Type System Tricks I Wish I Knew Earlier

Advanced TypeScript patterns I've learned from 8+ years in production - conditional types, template literals, and type-safe APIs that actually scale.

typescriptfrontenddx

Runtime Safety in React/TypeScript: Branded Types + Validation Boundaries

Where static types end and runtime bugs begin: branded types, parsing at boundaries, safer API contracts, and an error taxonomy that holds up in large React/TypeScript codebases.

typescriptreactruntime-safetyarchitecturefrontend

8 Lessons from 8 Years as a Frontend Engineer

Hard-earned wisdom from shipping products at Vietnamese startups and scale-ups. The things I wish someone told me when I started.

careerfrontendlessonsengineering

From Monolith to Micro-Frontends: Lessons from the Trenches

A candid look at what it's really like to break a React monolith into micro-frontends - the wins, the regrets, and what I'd do differently next time.

architecturemicro-frontendsreactfrontend

Hello World - Welcome to My Blog

An introduction to my blog where I'll be sharing thoughts on web development, React, and software engineering.

announcementpersonal
Subscribe via RSS