Senior Full-Stack Engineer / Product-oriented Engineer

I build and evolve software across frontend, backend, interactive applications, and cloud infrastructure.

I enjoy turning ambiguous product requirements into simple, maintainable systems — from prototype to production.

Languages
TypeScript · Python · C# · PHP · SQL

Product Development
React · Next.js · FastAPI · Spring Boot · Unity · Cocos Creator

Data & Infrastructure
PostgreSQL · MySQL · AWS · Cloudflare · GitHub Actions

Engineering Practices
DDD · Domain Modeling · Dependency Injection · TDD · BDD · Gherkin

AI / Interactive
LLM · VAD · STT · TTS · Three.js

• Product-oriented engineering
• Domain modeling & software architecture
• AI-assisted development
• Developer tooling and automation
• Functional programming & abstraction
• Interactive applications

Built and maintained systems across frontend, backend, APIs, databases, and cloud infrastructure, with a focus on keeping product logic independent from infrastructure.

Developed Unity-based applications integrating backend services, authentication, analytics, and platform-specific build pipelines.

Designed domain-oriented models and developer workflows to make complex product behavior easier to express, validate, and evolve.

• Start from the problem — understand the actual requirement before choosing an architecture
• Keep boundaries clear — isolate domain logic from replaceable infrastructure
• Prefer simple solutions — avoid introducing complexity without a concrete benefit
• Prototype early — validate assumptions before committing to large implementations
• Own problems end-to-end — move across frontend, backend, infrastructure, and product concerns

Validate before optimizing

Requirement
    ↓
Prototype
    ↓
Validation
    ↓
Production

Keep contracts stable and implementations replaceable

          Contract
         ↙        ↘
Implementation A   Implementation B

Keep product semantics independent from infrastructure

Domain
  ↓
Application
  ↓
Infrastructure

I prefer solving the actual problem over solving a more complicated version of it.

Make the implementation replaceable, and keep the semantics stable.