Runtime topology
How a single packet travels through one game loop, from client to storage.
Runtime snapshot
Production-minded backend operator
Current focus
Real-time backend, observability, and production-minded product delivery.
Status
Open to the right opportunities
Core stack
Node.js, TypeScript, WebSocket, SQL, Redis, internal tooling.
Runtime first
Connection flow, concurrency, and service behavior get my attention early, because real-time pressure exposes weak architecture fast.
Observability from day one
I build in monitoring, alerts, and logs while I'm building the feature, not as a fire drill after something breaks in production.
Delivery under real constraints
I ship backend work that stays maintainable even with legacy code, tight timelines, and a live product that isn't going to wait.
Signal set
Proof, in numbers
3+ years
Designing and running backend systems in production.
20+ servers
Real-time multiplayer game server instances built with Node.js and WebSocket.
High concurrency
Systems built to hold thousands of concurrent players without falling over.
-40%
Average incident response time cut by 40% after building better internal monitoring.
SQL + Redis + APIs
SQL Server, MySQL, Redis, MongoDB, REST APIs, and real-time messaging, used daily.
Production systems · Selected work
ONKY Game Server Systems
Production backend ownership across ONKY's online game products: server architecture, monitoring, and live operations.
Context
Real-time multiplayer products, where service behavior and runtime clarity affect live players directly, and backend stability isn't optional.
What I built
Built and extended multiplayer game servers with Node.js and WebSocket, added custom game logic on top of a shared framework, designed APIs for internal tools and lobby flows, and shipped internal SOS monitoring and process-management utilities.
Systems involved
Real-time socket communication, master-worker monitoring architecture, Redis-backed message flow, SQL-backed event logic, and incident tooling for live game instances.
Impact
20+ game server instances delivered, average incident response time down 40%, redundant SQL load reduced, and production debugging and rollouts made more predictable.
Node.jsWebSocketExpress.jsSQL ServerMySQLRedis
Product delivery · Selected work
VMU Test Exam
An online exam platform for medical students, with real-time admin visibility and backend support for controlled exam sessions.
Context
Students needed a testing flow that just worked. Admins needed enough visibility to monitor sessions and run the platform without guessing.
What I built
Worked on the backend-heavy product flows and session support connecting student activity to admin tooling, shaping the platform into something production-ready.
Systems involved
Node.js services, Socket.IO for real-time session visibility, MongoDB persistence, and a React front end, with operational flows for exam support.
Impact
Turned the system into a production-ready learning platform, with clearer moderation visibility and more reliable session handling during live exams.
Node.jsExpress.jsSocket.IOReactMongoDB
Systems exercise · Selected work
TinyLink
A compact URL shortener, built as a systems exercise around performance, observability, and reliability on a lean stack.
Context
A small service still has to earn its keep: fast redirects, sane data paths, and operational behavior that doesn't surprise you at 2am.
What I built
Designed the backend architecture, persistence layer, cache strategy, and deployment path around practical runtime choices, not abstract scale claims nobody was asking for.
Systems involved
Fastify runtime, PostgreSQL persistence, Redis caching, a Dockerized delivery path, and observability patterns sized for a lean service.
Impact
A working demonstration of backend judgment: fast redirects, reliability, and maintainability, kept compact and cost-aware on purpose.
Node.jsTypeScriptFastifyPostgreSQLRedisDocker
Platform build · Selected work
Matching Hub
Matchmaking-as-a-service for game servers: a multi-tenant platform handling player queuing, skill-based matching, Elo ratings, and webhook delivery.
Context
Every game studio rebuilds the same matchmaking plumbing: queues, rating windows, timeouts, result callbacks. Matching Hub centralizes that into one multi-tenant API so game servers don't have to own it.
What I built
Designed and built the platform end to end: a NestJS API with project/environment-scoped queues, three rating modes (internal Elo, external rating, or none), HMAC-signed webhook delivery with retry and backoff, and a Next.js dashboard for API keys, live pool monitoring, and match history.
Systems involved
NestJS + Prisma + PostgreSQL for the API, PostgreSQL-backed in-process schedulers for webhook retries and queue timeouts (no Redis needed), a Next.js dashboard that only talks to the API server-side, and a Docker/GHCR pipeline deploying to a VPS behind a Cloudflare Tunnel, with the dashboard on Vercel.
Impact
End-to-end platform ownership: API design, domain modeling, real security work (hashed keys, signed webhooks), and a CI/CD pipeline for a service meant to run unattended in production.
NestJSNext.jsTypeScriptPrismaPostgreSQLDocker
Capability architecture
The stack matters, but the real value is what each layer lets me ship confidently.
I group skills by what they let me build, not by a technology checklist. It maps better to how backend work actually gets delivered.
01 · Real-time systems
Event flow, sockets, and interactive runtime behavior
I'm comfortable in backend environments where connection handling, message timing, and event routing shape the end-user experience directly.
WebSocketSocket.IONode.jsEvent-driven architecture
02 · Backend runtime
API design and server-side product logic
Service logic, REST APIs, authentication flows, internal tools, and runtime structures that stay understandable as a product grows.
Node.jsExpress.jsREST APIsJWTTypeScript
03 · Data and performance
SQL, Redis, and throughput-focused backend decisions
I optimize data paths where query volume, concurrency, and latency actually matter: SQL tuning, cache usage, and cutting redundant work under load.
SQL ServerMySQLRedisMongoDBQuery optimization
04 · Operational tooling
Monitoring, incident response, and runtime visibility
Hands-on experience building internal monitoring and tooling that made alerting, reporting, and incident response faster in production.
Monitoring toolsTelegram APISlack APIProcess management
05 · Delivery surface
Enough range to ship complete outcomes
I can also work across the rest of the stack when a project needs it: internal tools, admin systems, and full-stack product flows.
ReactNext.jsFrontend deliveryAdmin tooling
Experience
A path through production backend work, full-stack delivery, and real-time systems.
The order matters: internships first, then product work and freelance delivery, then live game server systems under real concurrency.
Game Server Developer
Jul 2023 - Present
ONKY
Owned backend architecture and runtime stability for multiple online game products, covering server behavior, APIs, data performance, monitoring, and operational tooling.
- Built 20+ real-time multiplayer game servers with Node.js and WebSocket.
- Designed internal APIs and backend flows for lobby systems and operational tooling.
- Built SOS monitoring infrastructure with Telegram and Slack integrations.
- Optimized concurrency and reduced redundant SQL work under load.
Game Server Developer Intern
May 2023 - Jul 2023
ONKY
Started with low-level real-time backend work and system analysis, proving backend fundamentals through implementation clarity rather than framework abstraction.
- Built a 1v1 Caro game server from scratch using pure Node.js and WebSocket.
- Analyzed and documented an existing production game server codebase.
- Implemented a new multiplayer game server from company requirements.
- Completed internship tasks covering real-time backend and database handling.
Web Developer
Mar 2023 - Jul 2024
Freelancer
Delivered a full-stack learning and testing platform with role-aware access control, course material flows, scoring, and progress tracking.
- Designed and built a full-stack application with React, Express, Node.js, and MongoDB.
- Implemented JWT-based authentication and authorization.
- Delivered quiz, scoring, progress tracking, and user management features.
- Built a separate admin dashboard for users, lessons, and courses.
Web Developer
Aug 2022 - Apr 2023
FosTECH
Worked on frontend product delivery and integrations, contributing to product management surfaces, reporting flows, and build performance improvements.
- Built UI components and product-management screens for Proshop.
- Optimized Webpack configuration to improve load and build performance.
- Implemented API integration for dynamic reporting in WLIN CRM.
- Supported customer-relationship workflows through React-based interfaces.
Web Developer Intern
Jun 2022 - Aug 2022
FosTECH
Early product engineering work focused on third-party integration, payment flow correctness, and secure transaction behavior inside an existing React application.
- Integrated the Megapay payment solution into an existing React application.
- Implemented authentication and transaction flows from API specifications.
- Enabled secure in-app payments for end users.
- Completed integration work with production-minded correctness.
Working style
How I try to build backend systems that survive contact with production.
I care less about looking clever and more about whether the system is still reliable and easy to reason about once real traffic and incidents show up.
Principle 01 · Reliability
Optimize for behavior under pressure
Good backend work should still make sense when concurrency rises, incidents happen, or a live product exposes a weak assumption.
Principle 02 · Clarity
Keep runtime and code paths readable
I'd rather have a system that's easy to inspect and debug than an architecture that only looks impressive on paper.
Principle 03 · Concurrency
Design with load and timing in mind
Connection handling, event flow, and race conditions aren't edge cases in real-time products. They're the product.
Principle 04 · Visibility
Observability is part of delivery
Good monitoring shortens incident response and lowers the stress of being on call. That's the point of it, not a checkbox.
Open to the right conversations
Need backend ownership for real-time systems or production stability? Let's talk.
I'm a good fit for teams building multiplayer products, event-driven backends, or systems where reliability isn't optional.
Availability
Open to select freelance, consulting, and recruiter conversations with a real backend or systems angle.
Education
Bachelor of Engineering in Computer Science (Information Technology), Ho Chi Minh City University of Technology and Education.
Graduated 2019 - 2024 · GPA 8.61 / 10