Skip to content
Four Mental Models to Deconstruct Financial Architecture

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.

Code Farming
Code Farming
Code Farming

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.

FX cost reduction two-phase diagram
FX cost reduction two-phase diagram

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.

Boolean logic decomposition diagram
Boolean logic decomposition diagram

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.

POJO vs domain model comparison diagram
POJO vs domain model comparison diagram

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.

FX decomposition into two payments diagram
FX decomposition into two payments diagram

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.

Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

system designdomain-driven designpayment systemsdomain modelingfinancial architectureforeign exchangearchitectural thinkingnetting
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.