Lee ChanyangBackend Engineer

Language

Design Method

I turn requirements into verifiable designs

These are common questions for identifying which boundaries to examine first, not a claim that every project followed the same sequence. The B2B sample demonstrates requirements and role boundaries; production cases demonstrate state, authorization, and reprocessing boundaries.

Domain Analysis Process

From requirements to evidence of design, implementation, and operations

I classify requirements by purpose, actors, state changes, and policy and operational constraints, then connect them to domain language, architecture boundaries, use cases and API contracts, quality attributes, and operational recovery criteria.

01

Actor Specifications · B2B Sample

Classify requirements by purpose, actions, and constraints

Before building an API, I identify why the feature is needed, who changes which states, and how to uphold global constraints such as language and currency, policies, exceptions, and operational requirements.

View requirements classification evidence →
  • Actors
  • State changes
  • Use Cases
  • Policies and Global Constraints
02

Domain Retrospectives and Model Audits

Establish domain language, boundaries, and state models

I separate facts with different lifecycles—payments, billing, course access, subscriptions, refunds, points, and display language/currency—into models and state transitions.

View domain modeling evidence →
  • Lifecycles
  • Ownership
  • Language Boundaries
  • State Transitions
03

ADRs, Retrospectives, and Code Boundaries

Decide architecture boundaries and invariants

I establish invariants and tradeoffs for states that must be committed together, processing to hand off asynchronously, and boundaries that accommodate external system failures and regional expansion strategies.

View architecture decision evidence →
  • Transactions
  • Authoritative State
  • Retries
  • Region Strategy
04

API Contracts, Commits, and Tests

Connect the design to use cases, contracts, and code verification

I define API contracts, revalidation conditions, and test criteria for flows that deliver user value, such as previews, orders, payment initiation, authorization confirmation, callbacks, and status queries.

View implementation and verification evidence →
  • Use Cases
  • API Contracts
  • Tests
  • Audit Results
05

Infrastructure, Runbooks, and Deployment Documentation

Select infrastructure options that fit quality attributes

I select API server, Worker, object storage, Redis, logging, and deployment boundaries based on execution time, failure cost, retryability, observability, and cost constraints.

View infrastructure decision evidence →
  • Deployment Safety
  • Observability
  • Cost
  • Execution Boundaries
06

Recovery Retrospectives, Runbooks, and Code

Verify behavior after failure through operational and recovery criteria

I preserve idempotency keys, row locks, Outbox records, language-specific fallback messages, batch cursors, failure states, and operational documentation to make duplicate execution, partial failures, and reprocessing explainable.

View operations and recovery evidence →
  • Failure States
  • Reprocessing
  • Language-Specific Fallback Messages
  • Operational documentation

Decision Criteria

Decision criteria for turning requirements into system design

Before translating requirements directly into APIs, I identify the values the server must guarantee, the state it must retain, and the boundaries within which recovery is possible.

Rationale

I divide requirements into responsibility boundaries

Evidence of translating requirements into responsibility boundaries and domain language

Problem Definition

I mapped interface terminology to the responsibilities of the server, frontend, payment gateway, and operators.

Design Decisions

I separated purchases, billing, payment attempts, course entitlements, and subscription access into distinct models.

Verification Evidence

Extracted from payment, subscription, and refund flows and payment/entitlement documentation.