Interviewer: "Design a payment processing system."

Candidate: "OK so I'll have a PaymentController, and it will call a PaymentService,
            and the service will have a PaymentGateway, and we'll use Stripe, and
            we need a database for transactions, and there should be error handling,
            and maybe a queue for async processing, and logging, and..."

[20 minutes later: no diagram, no typed interfaces, no entity relationships defined]

├── 0–5 min   → Requirement clarification (ask; don't code yet)
├── 5–15 min  → Entity modeling (class diagram, relationships, aggregates)
├── 15–20 min → Critical sequence diagram (happy path + one failure branch)
├── 20–45 min → Implement core domain in TypeScript
│               ├── Domain types (branded primitives, discriminated unions)
│               ├── Aggregate root with private state
│               ├── Interfaces + DIP (ports in domain, adapters in infra)
│               └── Key behavioral pattern (Strategy, Observer, or State Machine)
└── 45–60 min → Probe defense
                ├── "How would you add [new feature]?"
                ├── "What if [failure scenario] occurs?"
                └── "How would you test [component]?"

// Mental checklist — ask these out loud:

const CLARIFICATION_QUESTIONS = [
  // 1. Primary entities
  "What are the core domain entities? (e.g., Order, Payment, Account, Customer?)",

  // 2. Operations
  "What are the primary operations? (Create, Update, Cancel, Refund, Query?)",

  // 3. Consistency requirement
  "Do we need strong consistency (no double-spend) or eventual consistency is acceptable?",

  // 4. Scale
  "Rough scale: how many concurrent users / transactions per second?",

  // 5. Extensibility
  "What is most likely to change in the future? (New payment providers? New order states?)",
] as const;

1. Extract all NOUNS from the problem statement.
   "Process orders from customers, each order has line items, 
   payments go through a gateway, refunds are tracked in a ledger."
   → Order, Customer, LineItem, Payment, Gateway, Refund, Ledger

2. Classify each noun:
   Entity (has identity, mutates)    → Order, Customer, Payment, Ledger
   Value Object (pure data, immutable) → Money, Address, DateRange
   Aggregate Root (guards cluster)  → OrderAggregate, LedgerEntry
   Service (stateless operations)   → PaymentService, RefundService
   Port (interface owned by domain) → IPaymentGateway, ILedgerRepository

3. Map relationships:
   Order *-- LineItem      (composition — lineitems die with order)
   Order --> Customer      (association — customer exists independently)
   Order --> IPaymentGateway (DIP — domain owns the interface)

Requirements established:
- Entities: Account, LedgerEntry, Transaction
- Operations: Debit, Credit, Transfer, QueryBalance, ExportStatement
- Consistency: Strong (double-entry bookkeeping — every debit must have a matching credit)
- Scale: 1,000 concurrent transactions per second
- Change vector: New regulatory reporting formats; new currencies

// ── domain/types.ts ──────────────────────────────────────────
declare const __brand: unique symbol;
type Brand<T, B extends string> = T & { readonly [__brand]: B };

type AccountId = Brand<string, 'AccountId'>;
type EntryId   = Brand<string, 'EntryId'>;

function asAccountId(raw: string): AccountId {
  if (!/^acc_[a-z0-9]{8,}$/.test(raw)) throw new Error(`Invalid AccountId: ${raw}`);
  return raw as AccountId;
}

// ── domain/Money.ts ──────────────────────────────────────────
class Money {
  constructor(readonly cents: number, readonly currency: 'USD' | 'EUR' | 'GBP') {
    if (!Number.isInteger(cents) || cents < 0) throw new RangeError('Invalid Money');
    Object.freeze(this);
  }
  add(other: Money): Money {
    if (this.currency !== other.currency) throw new Error('Currency mismatch');
    return new Money(this.cents + other.cents, this.currency);
  }
  subtract(other: Money): Money {
    if (this.cents < other.cents) throw new RangeError('Insufficient funds');
    return new Money(this.cents - other.cents, this.currency);
  }
}

// ── domain/AccountAggregate.ts ───────────────────────────────
class AccountAggregate {
  #balance: Money;
  readonly #entries: LedgerEntry[] = [];
  readonly accountId: AccountId;

  constructor(accountId: AccountId, initialBalance: Money) {
    this.accountId = accountId;
    this.#balance = initialBalance;
  }

  debit(amount: Money, reason: string): void {
    this.#balance = this.#balance.subtract(amount); // Throws if insufficient
    this.#entries.push(new LedgerEntry('DEBIT', amount, reason));
  }

  credit(amount: Money, reason: string): void {
    this.#balance = this.#balance.add(amount);
    this.#entries.push(new LedgerEntry('CREDIT', amount, reason));
  }

  get balance(): Money { return this.#balance; }
  get entries(): ReadonlyArray<LedgerEntry> { return this.#entries; }
}

type EntryType = 'DEBIT' | 'CREDIT';
class LedgerEntry {
  readonly entryId: EntryId = `ent_${Date.now()}_${Math.random().toString(36).slice(2)}` as EntryId;
  readonly occurredAt = new Date();
  constructor(
    readonly type: EntryType,
    readonly amount: Money,
    readonly reason: string,
  ) {}
}

// ── domain/ports/ILedgerRepository.ts ───────────────────────
interface ILedgerRepository {
  findById(id: AccountId): Promise<AccountAggregate | null>;
  save(account: AccountAggregate): Promise<void>;
}

// ── domain/TransferService.ts ────────────────────────────────
class TransferService {
  constructor(private readonly repo: ILedgerRepository) {}

  async transfer(fromId: AccountId, toId: AccountId, amount: Money): Promise<void> {
    const from = await this.repo.findById(fromId);
    const to   = await this.repo.findById(toId);

    if (!from) throw new Error(`Account not found: ${fromId}`);
    if (!to)   throw new Error(`Account not found: ${toId}`);

    from.debit(amount, `Transfer to ${toId}`);
    to.credit(amount, `Transfer from ${fromId}`);

    await Promise.all([this.repo.save(from), this.repo.save(to)]);
  }
}