Four Mental Models to Deconstruct Financial Architecture
This article presents four reusable reasoning models for financial system architecture: phased FX cost optimization via netting, Boolean logic for regulatory boundary analysis, anemic vs rich domain model trade-offs for cross-module data transfer, and decomposing FX transactions into paired same-currency payments to simplify complex designs.
Step 1: Reduce FX Costs — Launch First, Optimize Later
Cross-border FX cost reduction follows a two-phase evolution applicable to most new financial businesses.
Phase 1: Get the Business Running
Each FX transaction connects directly to an FX intermediary. The priority is to launch quickly while accumulating transaction data and user trading characteristics.
Phase 2: Financial Optimization via Netting
Once stable, build single-currency pools. Decompose FX trades into ordinary single-currency trades and use clearing/settlement to net positions.
Concrete example: A domestic user sends 1,000,000 USD to the US; a US user sends 800,000 USD back to China. After bidirectional netting, only the net 200,000 USD actually moves. Lower fund-flow volume directly reduces FX cost.
Risk & mitigation: If one-sided flow dominates, the pool can drain. The Phase-1 prediction capability forecasts liquidity needs for timely top-ups; if top-up is too slow, fall back to proxy FX conversion.
Step 2: Boolean Logic to Deconstruct Business & Regulatory Rules
Vague business or regulatory descriptions can be translated into logical propositions.
Example rule: "A AND B must both be true for the activity to be regulated." The AND operator means the whole proposition collapses if either condition fails.
Tracing this logic yields alternative business paths. While hunting loopholes is unsustainable (rules get patched), the real value is converting fuzzy definitions into precise logical structures. Identifying the logical relations inside a definition reveals the core entry point for system design.
Step 3: Cross-Domain Data Transfer — POJO vs Rich Domain Model
Choosing between anemic POJO/JSON and behavior-rich domain models depends on context.
Small teams / fast launch
Prefer POJOs; modules may even share database entities. This trades long-term maintainability for development speed — common in startup phase.
Large teams
POJOs carry only data, no validation or business behavior. Every caller must re-implement validation, duplicating rule interpretation. As business grows, inconsistencies and data errors multiply.
Rich domain models encapsulate validation, state transitions, and invariants. Module boundaries stay clean; correctness is easier to guarantee. Financial systems demand high data accuracy, so large enterprises often adopt domain models early despite a transition period of coexistence.
Step 4: One FX Trade = Two Same-Currency Trades
Complex FX business simplifies when viewed as two independent same-currency payments.
Implementation
Generate two payment orders in different currencies, link them, and record the trade-time rate and fee for reconciliation.
Fund-flow example
Domestic user pays 70 CNY → payment institution's CNY account.
Institution pre-buys FX → 10 USD placed in USD pool.
Transfer 10 USD from USD pool to overseas seller.
Architecture mapping
Rate service — frontend quoting.
Clearing center — bidirectional netting to cut cost.
FX gateway — connects external asset managers and FX networks.
Accounting, gateway, core ledger — reuse existing payment-system modules.
DDD modeling extension
Cross-entity actions → domain services.
Attributes like exercise date → value objects.
Common capabilities like messaging → generic domain.
Unified Thinking Template
When facing an unfamiliar financial requirement, ask four questions in sequence:
Can we phase the rollout? Launch first to accumulate data, then optimize cost and architecture.
What are the logical relations in the rule definitions? Use Boolean logic to delineate business and regulatory boundaries.
Does cross-module data need to carry business behavior? Choose anemic vs rich models based on team size and fault tolerance.
Can a perspective shift break the problem into familiar primitives? Example: decompose FX into two same-currency payments.
Conclusion
Financial systems are never built once; they grow iteratively with the business. The essence of architecture is not stacking components but anticipating the business's evolution path so the system can grow alongside it. Mastering problem decomposition matters far more than memorizing solution patterns.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
