Vietnam · UTC+7

Hello, I'mNguyen Duy Thuan

<Senior Full Stack /> I own systems end to end — from the product surface a user touches to the payment routing, event stream and locking that keep it standing up.

years
7
flagship products
2
production services
7
ContactLinkedIn (opens in a new tab) GitHub (opens in a new tab)
profile.ts
// Senior full-stack product engineer
const profile = {
name: "Nguyen Duy Thuan",
stack: "TypeScript, React, Next.js, NestJS",
depth: ["backend architecture",
"payment systems",
"serverless automation"],
currently: "payment routing, mobile deep-linking",
};

# About.system

Nguyen Duy Thuan
>_user_profile.log

whoami

Senior full-stack product engineer. Seven years on one long-lived product, moving from its frontend into the backends and mobile apps behind it — which means I have had to live with my own architectural decisions rather than hand them over.

cat how-i-work.txt

I take a domain and own it in production: the schema, the migrations, the failure modes, and the pager. Most of what I have shipped is invisible when it works — payment routing that settles, locks that survive a failover, scrapers that keep returning data when a site changes shape.

cat looking-for.txt

Looking for senior full-stack work where backend architecture meets a real product surface, on a team that treats production ownership as part of engineering rather than a separate role.

Where the depth is

  • Backend architecture

    NestJS and TypeScript with DDD boundaries, contract-first APIs, and per-domain integration suites.

  • Payment systems

    Multi-account and multi-currency routing, idempotent webhooks, and localized checkout on both server and client.

  • Serverless automation

    Headless-browser extraction on Lambda, with resilient crawling and self-healing distributed locks.

# Experience.git

HEADHEAD → full-stack
URBN8

Senior Full Stack Product Engineer @ URBN8

Vietnam · Remote

2019-09 – Present

  • Owned NestJS and TypeScript backend domains using DDD and hexagonal patterns across a long-lived product.
  • Designed Stripe payment integrations spanning multi-account and multi-currency routing, Connect flows, PaymentElement, and idempotent webhooks.
  • Architected serverless link extraction with reusable crawler strategies and production-ready browser execution on AWS Lambda.
  • Delivered React and Next.js product surfaces plus Capacitor mobile flows, including deferred deep-link recovery after installation and verification.
  • backend architecture
  • payments
  • mobile
  • serverless

Factual stack

  • TypeScript
  • React
  • Next.js
  • MobX
  • Capacitor
  • NestJS
  • Node.js
  • Stripe
  • PostgreSQL
  • Redis
  • AWS
  • Docker

// Experience timeline

  1. 2020 – 2021

    Frontend foundations

    Built product surfaces with Next.js and React, styled-components, SSR, and visual-regression coverage.

    • Next.js
    • React
    • SSR
    • visual regression

  2. 2021 – 2022

    Shift to backend

    Started building NestJS services and took ownership of server-side domains.

    • NestJS
    • TypeScript
    • backend domains

  3. 2023

    Backend ownership & scale-out

    Moved payments, event sourcing, and migrations server-side while expanding into serverless automation and a second product surface.

    • payments
    • event sourcing
    • migrations
    • serverless

  4. 2024 – 2025

    Mobile & quality breadth

    Delivered Capacitor app features alongside BDD specifications, end-to-end helpers, and standalone campaign builds.

    • Capacitor
    • BDD
    • E2E
    • campaigns

  5. 2026

    Senior full-stack

    Continued full-stack ownership across payment routing, deep links, distributed locks, and geospatial export.

    • payment routing
    • deep linking
    • Redis
    • PostGIS

// Case studies

6 sanitized deep-dives

Payments

Multi-region payment abstraction

Context
A product needed one payment flow across accounts, currencies, and regional providers.
Problem
Provider-specific behavior made routing, Connect flows, and webhook processing difficult to keep consistent.
Approach
  • Defined a provider-pool abstraction for regional and currency-aware charge routing.
  • Implemented Connect flows and PaymentElement integration across server and client paths.
  • Made webhook handling idempotent with an always-acknowledge processing boundary.
Outcome
Payment flows share one routing model while safely handling repeated webhook delivery.

Stack

  • NestJS
  • TypeScript
  • Stripe
  • React
  • PaymentElement

Distributed systems

Self-healing distributed lock layer

Context
Multiple service instances needed Redis-backed coordination for shared work.
Problem
Redis failover and transient connection failures could interrupt lock acquisition and release.
Approach
  • Built a typed lock service around Redis and Redlock.
  • Added reconnect debouncing to avoid recovery storms during failover.
  • Used a generic typed backoff helper for retryable operations.
Outcome
The lock layer reconnects through Redis failover without dropping coordination guarantees.

Stack

  • TypeScript
  • NestJS
  • Redis
  • Redlock

Automation

Headless-browser extraction on serverless

Context
A first-party link-extraction service needed to collect metadata from difficult pages in a serverless runtime.
Problem
Pages varied in behavior, while headless Chromium introduced packaging and runtime constraints on Lambda.
Approach
  • Structured extraction behind HTTP, oEmbed, and headless-browser strategies.
  • Packaged Chromium for Lambda and added proxy support for resilient execution.
  • Added URL sanitization and browser compatibility measures for difficult sites.
Outcome
The service selects an appropriate extraction strategy and runs browser-based collection within Lambda constraints.

Stack

  • NestJS
  • TypeScript
  • Puppeteer
  • AWS Lambda
  • Metascraper

Mobile

Deferred deep-linking for a Capacitor app

Context
Users could arrive through a link before installing the mobile app or completing email verification.
Problem
The destination context was easy to lose across installation, authentication, and cold starts.
Approach
  • Captured deferred link state before installation and propagated it through the app lifecycle.
  • Added recovery after email verification and across the cold-start path.
  • Connected web and Capacitor entry points into one resume flow.
Outcome
A link can resume its intended destination after installation and verification instead of losing context.

Stack

  • Capacitor
  • React
  • Next.js
  • TypeScript
  • Deep linking

Distributed systems

Event-sourced domain on NATS JetStream

co-owned
Context
A core domain needed durable events and separate read and write concerns.
Problem
Domain changes had to remain replayable while serving current read models through asynchronous updates.
Approach
  • Co-owned a CQRS and event-sourcing subsystem around NATS JetStream.
  • Separated domain events from projections used by read-side consumers.
  • Kept event publication durable for later replay and recovery.
Outcome
The domain has a durable event stream that supports replayable state changes and independent projections.

Stack

  • TypeScript
  • NestJS
  • NATS JetStream
  • CQRS
  • Event sourcing

Frontend performance

Zero-re-render drag & resize dashboard

Context
An interactive dashboard needed fluid drag and resize behavior for configurable layouts.
Problem
Updating React state on every pointer movement caused unnecessary render churn during interaction.
Approach
  • Manipulated layout DOM nodes through refs during active pointer movement.
  • Kept persistent layout state separate from the transient interaction path.
  • Returned control to the normal React update flow when the interaction completed.
Outcome
Drag and resize interactions avoid React re-render churn while preserving the final layout state.

Stack

  • React
  • TypeScript
  • Vite
  • React Grid Layout

# Skills.json

Loading skills graph…

Languages

  • TypeScript
  • JavaScript
  • SQL
  • Swift
  • Go

Backend

  • NestJS
  • Node.js
  • Express
  • REST
  • ts-rest
  • Swagger/OpenAPI
  • DDD/hexagonal
  • CQRS/event sourcing

Frontend

  • React
  • Next.js
  • MobX
  • styled-components
  • Storybook
  • i18n (next-i18next)
  • Vite

Mobile

  • Capacitor
  • deep linking (Branch.io)
  • Fastlane
  • Trapeze

Payments

  • Stripe (Connect, PaymentElement, webhooks, multi-account/multi-currency)

Databases

  • PostgreSQL
  • Prisma
  • Kysely
  • Knex
  • pgBouncer
  • PostGIS
  • Cassandra
  • Redis
  • Redlock

Messaging & Events

  • NATS JetStream
  • AWS SQS/SNS

Cloud & Serverless

  • AWS (Lambda, S3, ECR, SDK v3)
  • Serverless Framework
  • Cloudflare Workers/R2

DevOps

  • Docker (multi-stage)
  • GitLab CI/CD
  • Kubernetes/Helm (operator-level)
  • Kaniko

Testing

  • Jest (unit + integration/supertest)
  • Playwright
  • Vitest
  • visual regression
  • BDD/Gherkin

Automation

  • Puppeteer
  • headless-Chromium scraping
  • scraping resilience
  • metascraper/cheerio

Observability

  • Sentry
  • New Relic
  • Bunyan

$ ./contact.exe

TSsendMessage.tsx
mail.composesecure channel
to: [email protected]

// Validated server-side · bot-filtered