Introduction

This 5-day intensive preparation guide is designed for Architecture Online Assessment (OA). Architecture OAs typically focus on designing scalable, high-performance financial systems that handle real-time trading, market data, and millions of transactions. The assessment emphasizes fintech domain knowledge, low-latency systems, data consistency, and reliability.

Key Characteristics of Architecture OA:

  • Fintech Focus: Trading systems, order management, market data
  • Real-Time Requirements: Low-latency order execution, live market data
  • High Reliability: Financial transactions must be accurate and consistent
  • Scalability: Millions of users, billions of transactions
  • Regulatory Compliance: SEC, FINRA requirements and audit trails

OA Format Expectations:

  • Duration: 60-90 minutes (typically)
  • Format: System design problem(s) with architecture diagrams
  • Focus: Backend architecture, distributed systems, trading infrastructure
  • Evaluation: Problem-solving approach, technical depth, fintech expertise

Day 1: Trading Systems & Order Management

Morning (2-3 hours)

Core Concepts to Master:

  • Order lifecycle: placement → validation → matching → execution → settlement
  • Order types: market orders, limit orders, stop orders
  • Order matching algorithms: price-time priority, pro-rata matching
  • Order book data structures: price-time priority queues
  • Market data feeds: real-time price updates, order book snapshots
  • Order routing: routing to market makers, exchange connectivity

Key Topics:

  • Order execution flow and latency requirements
  • Order matching engine design
  • Order book management (bid/ask queues)
  • Real-time order status updates
  • Order cancellation and modification
  • Partial order fulfillment

Afternoon (2-3 hours)

Practice Exercises:

  • Design an Order Matching Engine
    • Draw architecture: Order Gateway → Matching Engine → Execution Engine
    • Design data structures for order book (price-time priority)
    • Explain matching algorithm (FIFO, pro-rata)
    • Handle concurrent orders and race conditions
  • Design a Limit Order System
    • Order storage and retrieval
    • Order expiration handling
    • Partial fulfillment logic
    • Real-time order status updates
  • Architecture Diagram: Order execution flow
    • Client → API Gateway → Order Service → Matching Engine → Market

Mock OA Question:

“Design a real-time order execution system that can handle millions of orders per second. Include order matching, status updates, and audit logging.”

Key Points to Cover:

  • Ultra-low latency architecture (microseconds)
  • High-throughput order processing
  • Order matching algorithm (price-time priority)
  • Order book data structures (trees, heaps)
  • Real-time status updates (WebSocket, server-sent events)
  • Audit trail and compliance
  • Fault tolerance and error handling

Resources:

Day 2: Real-Time Market Data & Data Feeds

Morning (2-3 hours)

Core Concepts to Master:

  • Market data feeds: Level 1 (BBO), Level 2 (order book), Level 3 (full depth)
  • Real-time data distribution: pub-sub, WebSocket, server-sent events
  • Data feed aggregation: combining multiple exchange feeds
  • Snapshot and incremental updates: efficient data transmission
  • Data feed reliability: redundancy, failover, backfill
  • Historical data storage: time-series databases, data retention

Key Topics:

  • Market data feed architecture
  • Real-time data streaming (Kafka, Pulsar)
  • Data normalization across exchanges
  • Low-latency data distribution
  • Data feed caching strategies
  • Handling feed outages and recovery

Afternoon (2-3 hours)

Practice Exercises:

  • Design a Market Data Feed System
    • Draw architecture: Exchange Feeds → Aggregator → Distribution → Clients
    • Design pub-sub system for data distribution
    • Handle multiple exchange feeds and normalization
    • Implement snapshot and incremental updates
  • Design Real-Time Price Update System
    • WebSocket connection management
    • Efficient data serialization (protobuf, messagepack)
    • Client-side caching and throttling
    • Handling connection failures and reconnection
  • Architecture Diagram: Market data pipeline
    • Data Sources → Processing → Storage → Distribution → Clients

Mock OA Question:

“Design a system to distribute real-time stock price updates to millions of users. Handle high-frequency updates, connection management, and ensure low latency.”

Key Points to Cover:

  • Market data feed aggregation
  • Pub-sub architecture (Kafka, Redis Pub/Sub)
  • WebSocket connection management
  • Data compression and serialization
  • Client-side throttling and batching
  • Connection pooling and load balancing
  • Fault tolerance and failover

Resources:

  • “Designing Data-Intensive Applications” - Chapter 11: Stream Processing
  • “High Performance Browser Networking” - WebSocket chapter
  • Real-time data streaming patterns

Day 3: Portfolio Management & Account Systems

Morning (2-3 hours)

Core Concepts to Master:

  • Portfolio valuation: real-time position tracking, P&L calculations
  • Account balance management: cash, buying power, margin
  • Transaction processing: deposits, withdrawals, trades
  • Position tracking: holdings, cost basis, unrealized P&L
  • Multi-asset support: stocks, options, crypto, fractional shares
  • Regulatory compliance: account statements, tax reporting

Key Topics:

  • Real-time portfolio calculations
  • Balance consistency and accuracy
  • Transaction atomicity and idempotency
  • Historical performance tracking
  • Multi-currency support
  • Regulatory reporting and audit trails

Afternoon (2-3 hours)

Practice Exercises:

  • Design a Portfolio Management System
    • Draw architecture: Transaction Service → Portfolio Service → Valuation Engine
    • Design data model for positions and transactions
    • Real-time P&L calculation strategy
    • Handle concurrent transactions and consistency
  • Design an Account Balance System
    • Balance update flow: Transaction → Validation → Update
    • Handle concurrent balance updates (distributed locks, optimistic locking)
    • Transaction rollback and error handling
    • Multi-currency balance management
  • Architecture Diagram: Portfolio update flow
    • Trade Execution → Transaction Log → Portfolio Update → Cache → UI

Mock OA Question:

“Design a portfolio management system that tracks user positions in real-time, calculates P&L, and handles millions of concurrent transactions while ensuring data consistency.”

Key Points to Cover:

  • Real-time portfolio valuation architecture
  • Transaction processing pipeline
  • Data consistency (ACID, eventual consistency trade-offs)
  • Caching strategy for portfolio data
  • Position and transaction data models
  • P&L calculation algorithms
  • Handling concurrent updates (optimistic locking, distributed locks)

Resources:

  • “Designing Data-Intensive Applications” - Chapter 7: Transactions, Chapter 9: Consistency
  • Database transaction patterns
  • Financial system design patterns

Day 4: Scalability, Reliability & System Architecture

Morning (2-3 hours)

Core Concepts to Master:

  • System scalability: horizontal scaling, load balancing, sharding
  • Database design: relational vs NoSQL, read replicas, partitioning
  • Caching strategies: Redis, CDN, application-level caching
  • Message queues: Kafka, RabbitMQ for async processing
  • Fault tolerance: circuit breakers, retries, graceful degradation
  • Monitoring and observability: metrics, logging, alerting

Key Topics:

  • Microservices architecture patterns
  • Database sharding strategies
  • Caching layers and invalidation
  • Async processing with message queues
  • Rate limiting and throttling
  • Disaster recovery and backup strategies

Afternoon (2-3 hours)

Practice Exercises:

  • Design a Scalable Trading System Architecture
    • Draw microservices architecture
    • Database sharding strategy (by user, by symbol)
    • Caching layers (L1: in-memory, L2: Redis)
    • Load balancing and auto-scaling
  • Design Fault-Tolerant System
    • Circuit breakers for external dependencies
    • Retry mechanisms with exponential backoff
    • Graceful degradation strategies
    • Disaster recovery plan
  • Architecture Diagram: Complete system architecture
    • Load Balancer → API Gateway → Services → Databases
    • Include caching, queues, monitoring

Mock OA Question:

“Design a scalable architecture for a trading platform that can handle 10x traffic spikes, ensure 99.99% uptime, and maintain data consistency across distributed systems.”

Key Points to Cover:

  • Horizontal scaling strategies
  • Database architecture (sharding, replication)
  • Caching architecture (multi-layer)
  • Message queue for async processing
  • Load balancing and auto-scaling
  • Fault tolerance mechanisms
  • Monitoring and alerting
  • Disaster recovery

Resources:

  • “Designing Data-Intensive Applications” - Chapter 5: Replication, Chapter 6: Partitioning
  • “System Design Interview” by Alex Xu - Scalability chapters
  • Microservices patterns

Day 5: Mock OA & Fintech-Specific Topics

Morning (2-3 hours)

Fintech-Specific Topics:

  • Regulatory compliance: SEC, FINRA requirements, audit trails
  • Security: encryption, authentication, fraud detection
  • Risk management: position limits, margin requirements
  • Settlement and clearing: T+2 settlement, trade reconciliation
  • Payment processing: ACH, wire transfers, instant deposits
  • Tax reporting: 1099 forms, cost basis tracking

Key Topics:

  • Financial regulations and compliance
  • Security best practices for financial data
  • Risk management systems
  • Payment gateway integration
  • Audit logging and reporting
  • Data retention policies

Afternoon (3-4 hours)

Full Mock OA Practice:

Option 1: Complete Trading System

“Design an end-to-end stock trading platform that supports order placement, real-time market data, portfolio tracking, and account management. Handle millions of users and ensure regulatory compliance.”

Time Breakdown:

  • Clarify requirements (10 min)
  • High-level architecture (15 min)
  • Detailed component design (20 min)
  • Data models and APIs (10 min)
  • Scalability and reliability (10 min)
  • Fintech considerations (5 min)

Key Areas to Cover:

  • Order execution system
  • Market data distribution
  • Portfolio management
  • Account and balance management
  • User authentication and authorization
  • Audit logging and compliance
  • Scalability and fault tolerance

Option 2: Real-Time Market Data System

“Design a system to aggregate market data from multiple exchanges, normalize the data, and distribute real-time price updates to millions of users with sub-100ms latency.”

Time Breakdown:

  • Clarify requirements (10 min)
  • Data flow architecture (15 min)
  • Aggregation and normalization (15 min)
  • Distribution mechanism (15 min)
  • Scalability and reliability (10 min)
  • Trade-offs discussion (5 min)

Key Areas to Cover:

  • Market data feed ingestion
  • Data aggregation and normalization
  • Real-time distribution (pub-sub, WebSocket)
  • Connection management
  • Caching and optimization
  • Fault tolerance and failover

Option 3: Portfolio Management System

“Design a portfolio management system that tracks user positions across multiple asset types (stocks, options, crypto), calculates real-time P&L, and handles concurrent transactions while maintaining data consistency.”

Time Breakdown:

  • Clarify requirements (10 min)
  • Transaction processing (15 min)
  • Portfolio calculation (15 min)
  • Data consistency (15 min)
  • Scalability (10 min)
  • Compliance (5 min)

Key Areas to Cover:

  • Transaction processing pipeline
  • Position tracking and storage
  • Real-time P&L calculation
  • Data consistency mechanisms
  • Multi-asset support
  • Historical tracking and reporting

Self-Evaluation Checklist: After mock OA, evaluate:

  • Clearly clarified requirements and constraints
  • Drew comprehensive architecture diagrams
  • Discussed fintech-specific considerations
  • Addressed real-time and low-latency requirements
  • Covered scalability and reliability
  • Explained data consistency strategies
  • Discussed trade-offs with justification
  • Stayed within time limit
  • Communicated clearly and structured answers

Key Fintech Concepts to Know

Trading Concepts

  • Order Types: Market, Limit, Stop, Stop-Limit orders
  • Order Matching: Price-time priority, pro-rata matching
  • Order Book: Bid/ask queues, best bid/offer (BBO), market depth
  • Settlement: T+2 settlement cycle, trade reconciliation
  • Margin Trading: Buying power, margin requirements, margin calls

Market Data

  • Level 1 Data: Best bid and offer (BBO)
  • Level 2 Data: Full order book depth
  • Level 3 Data: Full market depth with order IDs
  • Tick Data: Individual trade executions
  • OHLCV: Open, High, Low, Close, Volume data

Financial Regulations

  • SEC Regulations: Securities and Exchange Commission rules
  • FINRA: Financial Industry Regulatory Authority
  • Best Execution: Requirement to execute orders at best available price
  • NMS: National Market System regulations
  • Audit Trail: Complete record of all transactions

Risk Management

  • Position Limits: Maximum position size per user
  • Margin Requirements: Minimum equity requirements
  • Circuit Breakers: Trading halts during extreme volatility
  • Pre-trade Checks: Validation before order execution
  • Post-trade Monitoring: Risk monitoring after execution

Common OA Patterns & Anti-Patterns

✅ Good Patterns

  1. Start with Requirements Clarification
    • Ask about scale (users, transactions per second)
    • Understand latency requirements
    • Clarify consistency requirements
    • Identify regulatory constraints
  2. Design Bottom-Up
    • Start with core components
    • Build up to full system
    • Show data flow clearly
    • Identify bottlenecks early
  3. Address Fintech-Specific Concerns
    • Data consistency and accuracy
    • Audit logging and compliance
    • Security and fraud prevention
    • Risk management
  4. Discuss Trade-offs Explicitly
    • Consistency vs availability
    • Latency vs throughput
    • Cost vs performance
    • Complexity vs maintainability

❌ Common Mistakes

  1. Ignoring Fintech Requirements
    • Missing audit trails
    • Not addressing regulatory compliance
    • Skipping security considerations
    • Forgetting data consistency
  2. Over-Engineering
    • Adding unnecessary complexity
    • Over-distributing when not needed
    • Over-optimizing prematurely
  3. Under-Specifying
    • Vague architecture diagrams
    • Missing key components
    • Not addressing failure scenarios
    • Skipping scalability considerations
  4. Poor Time Management
    • Spending too much time on one component
    • Not leaving time for trade-offs discussion
    • Rushing through critical parts

Quick Reference: Key Technologies

Databases

  • PostgreSQL: ACID transactions, financial data
  • Redis: Caching, pub-sub, real-time data
  • Time-Series DBs: InfluxDB, TimescaleDB for market data
  • NoSQL: MongoDB for flexible schemas (use cautiously for financial data)

Message Queues

  • Kafka: High-throughput event streaming
  • RabbitMQ: Reliable message queuing
  • Redis Streams: Lightweight streaming

Caching

  • Redis: Distributed caching, pub-sub
  • Memcached: Simple key-value caching
  • CDN: Static content and API caching

Real-Time Communication

  • WebSocket: Bi-directional real-time communication
  • Server-Sent Events (SSE): One-way server-to-client
  • gRPC: High-performance RPC for internal services

Monitoring & Observability

  • Prometheus: Metrics collection
  • Grafana: Metrics visualization
  • ELK Stack: Log aggregation and analysis
  • Distributed Tracing: Jaeger, Zipkin

Final Preparation Checklist

Technical Knowledge

  • Understand order execution flow
  • Know market data feed architecture
  • Familiar with portfolio management concepts
  • Understand fintech regulations basics
  • Know scalability patterns
  • Understand data consistency models

Design Skills

  • Can draw clear architecture diagrams
  • Can design APIs and data models
  • Can discuss trade-offs clearly
  • Can identify bottlenecks
  • Can design for fault tolerance

Fintech Domain

  • Understand trading concepts
  • Know market data types
  • Familiar with regulatory requirements
  • Understand risk management basics
  • Know settlement processes

OA Readiness

  • Practiced timed mock OAs
  • Can work under time pressure
  • Clear communication skills
  • Structured problem-solving approach
  • Comfortable with whiteboard/diagramming tools

Conclusion

This 5-day preparation plan provides focused, intensive preparation for Architecture OA. Each day builds essential knowledge and skills:

  1. Day 1: Trading systems and order management (core)
  2. Day 2: Real-time market data and data feeds (critical)
  3. Day 3: Portfolio and account systems (important)
  4. Day 4: Scalability and reliability (foundational)
  5. Day 5: Mock OA and fintech-specific topics (practice)

Key Success Factors:

  • Master fintech domain concepts
  • Focus on real-time and low-latency requirements
  • Emphasize data consistency and reliability
  • Address regulatory compliance
  • Practice under time constraints
  • Communicate clearly and structure answers

Remember:

  • Fintech companies value fintech domain knowledge
  • Real-time performance is critical
  • Data consistency is non-negotiable
  • Regulatory compliance is essential
  • Scalability must be addressed from the start

Good luck with your Architecture OA! 🚀📈