System Design Interview

Wrap Up

Wrap up 2 min readLesson 4 of 4

In this chapter, we designed a wallet service that is capable of processing over 1 million payment commands per second. After a back-of-the-envelope estimation, we concluded that a few thousand nodes are required to support such a load.

In the first design, a solution using in-memory key-value stores like Redis is proposed. The problem with this design is that data isn't durable.

In the second design, the in-memory cache is replaced by transactional databases. To support multiple nodes, different transactional protocols such as 2PC, TC/C, and Saga are proposed. The main issue with transaction-based solutions is that we cannot conduct a data audit easily.

Next, event sourcing is introduced. We first implemented event sourcing using an external database and queue, but it’s not performant. We improved performance by storing command, event, and state in a local node.

A single node means a single point of failure. To increase the system reliability, we use the Raft consensus algorithm to replicate the event list onto multiple nodes.

The last enhancement we made was to adopt the CQRS feature of event sourcing. We added a reverse proxy to change the asynchronous event sourcing framework to a synchronous one for external users. The TC/C or Saga protocol is used to coordinate Command executions across multiple node groups.

Congratulations on getting this far! Now give yourself a pat on the back. Good job!

Chapter Summary

Figure — this diagram isn't included in the course export.

Reference materials

  1. Transactional guarantees: https://docs.oracle.com/cd/E17275_01/html/programmer_reference/rep_trans.html
  2. TPC-E Top Price/Performance Results: http://tpc.org/tpce/results/tpce_price_perf_results5.asp?resulttype=all
  3. ISO 4217 CURRENCY CODES: https://en.wikipedia.org/wiki/ISO_4217
  4. Apache Zookeeper: https://zookeeper.apache.org/
  5. Martin Kleppmann (2017). Designing Data-Intensive Applications. O'Reilly Media.
  6. X/Open XA: https://en.wikipedia.org/wiki/X/Open_XA
  7. Compensating transaction: https://en.wikipedia.org/wiki/Compensating_transaction
  8. SAGAS, HectorGarcia-Molina: https://www.cs.cornell.edu/andru/cs711/2002fa/reading/sagas.pdf
  9. Evans, E. (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Addison-Wesley Professional.
  10. Apache Kafka. https://kafka.apache.org/
  11. CQRS: https://martinfowler.com/bliki/CQRS.html
  12. Comparing Random and Sequential Access in Disk and Memory: https://deliveryimages.acm.org/10.1145/1570000/1563874/jacobs3.jpg
  13. mmap: https://man7.org/linux/man-pages/man2/mmap.2.html
  14. SQLite: https://www.sqlite.org/index.html
  15. RocksDB. https://rocksdb.org/
  16. Apache Hadoop: https://hadoop.apache.org/
  17. Raft: https://raft.github.io/
  18. Reverse proxy: https://en.wikipedia.org/wiki/Reverse_proxy

Finished reading?

Mark it complete to track your progress.

PreviousDesign Deep DiveDigital WalletNext Understand the ProblemStock Exchange