Description
Acing the System Design Interview Video Edition course. This tutorial is visual, meaning the narrator reads the book while the content, figures, code listings, diagrams, and text are displayed on the screen. This course is like an audio book that you can also watch as a video. With this course, don’t be afraid of the complex and open nature of system design in job interviews! In this comprehensive guide, author Zhiyang Tan shares his experiences from both sides of the interview table. You’ll dive deep into common technical topics that come up during interviews and learn how to apply them to the conceptual design of different types of systems.
What you will learn
- An organized approach to presenting system design ideas such as:
- Scale applications to support high workloads
- Distributed transaction techniques to ensure data consistency
- Services for functional partitioning such as API Gateway and Mesh Service
- Common API patterns including REST, RPC and GraphQL
- Caching strategies, along with their pros and cons
- Logging, monitoring and alerting concepts that are critical to any system design
- Communication skills that demonstrate your engineering maturity
This course is suitable for people who:
- Software engineers
- Software architects
- Engineering managers
- Looking for advancement in their career
Course headings
- Part 1.
- Chapter 1. A walkthrough of system design concepts
- Chapter 1. Should you read this book?
- Chapter 1. Overview of this book
- Chapter 1. Prelude: A brief discussion of scaling the various services of a system
- Chapter 1. Summary
- Chapter 2. A typical system design interview flow
- Chapter 2. Draft the API specification
- Chapter 2. Connections and processing between users and data
- Chapter 2. Design the data model
- Chapter 2. Logging, monitoring, and alerting
- Chapter 2. Search bar
- Chapter 2. Other discussions
- Chapter 2. Post-interview reflection and assessment
- Chapter 2. Interviewing the company
- Chapter 2. Summary
- Chapter 3. Non-functional requirements
- Chapter 3. Availability
- Chapter 3. Fault-tolerance
- Chapter 3. Performance/latency and throughput
- Chapter 3. Consistency
- Chapter 3. Accuracy
- Chapter 3. Complexity and maintainability
- Chapter 3. Cost
- Chapter 3. Security
- Chapter 3. Privacy
- Chapter 3. Cloud native
- Chapter 3. Further reading
- Chapter 3. Summary
- Chapter 4. Scaling databases
- Chapter 4. When to use vs. avoid databases
- Chapter 4. Replication
- Chapter 4. Scaling storage capacity with sharded databases
- Chapter 4. Aggregating events
- Chapter 4. Batch and streaming ETL
- Chapter 4. Denormalization
- Chapter 4. Caching
- Chapter 4. Caching as a separate service
- Chapter 4. Examples of different kinds of data to cache and how to cache them
- Chapter 4. Cache invalidation
- Chapter 4. Cache warming
- Chapter 4. Further reading
- Chapter 4. Summary
- Chapter 5. Distributed transactions
- Chapter 5. Event sourcing
- Chapter 5. Change Data Capture (CDC)
- Chapter 5. Comparison of event sourcing and CDC
- Chapter 5. Transaction supervisor
- Chapter 5. Saga
- Chapter 5. Other transaction types
- Chapter 5. Further reading
- Chapter 5. Summary
- Chapter 6. Common services for functional partitioning
- Chapter 6. Service mesh/sidecar pattern
- Chapter 6. Metadata service
- Chapter 6. Service discovery
- Chapter 6. Functional partitioning and various frameworks
- Chapter 6. Library vs. service
- Chapter 6. Common API paradigms
- Chapter 6. Summary
- Part 2.
- Chapter 7. Design Craigslist
- Chapter 7. API
- Chapter 7. SQL database schema
- Chapter 7. Initial high-level architecture
- Chapter 7. A monolith architecture
- Chapter 7. Using an SQL database and object store
- Chapter 7. Migrations are troublesome
- Chapter 7. Writing and reading posts
- Chapter 7. Functional partitioning
- Chapter 7. Caching
- Chapter 7. CDN
- Chapter 7. Scaling reads with a SQL cluster
- Chapter 7. Scaling write throughput
- Chapter 7. Email service
- Chapter 7. Search
- Chapter 7. Removing old posts
- Chapter 7. Monitoring and alerting
- Chapter 7. Summary of our architecture discussion so far
- Chapter 7. Other possible discussion topics
- Chapter 7. Summary
- Chapter 8. Design a rate-limiting service
- Chapter 8. When not to do rate limiting
- Chapter 8. Functional requirements
- Chapter 8. Non-functional requirements
- Chapter 8. Discuss user stories and required service components
- Chapter 8. High-level architecture
- Chapter 8. Stateful approach/sharding
- Chapter 8. Storing all counts in every host
- Chapter 8. Rate-limiting algorithms
- Chapter 8. Employing a sidecar pattern
- Chapter 8. Logging, monitoring, and alerting
- Chapter 8. Providing functionality in a client library
- Chapter 8. Further reading
- Chapter 8. Summary
- Chapter 9. Design a notification/alerting service
- Chapter 9. Non-functional requirements
- Chapter 9. Initial high-level architecture
- Chapter 9. Object store: Configuring and sending notifications
- Chapter 9. Notification templates
- Chapter 9. Scheduled notifications
- Chapter 9. Notification addressee groups
- Chapter 9. Unsubscribe requests
- Chapter 9. Handling failed deliveries
- Chapter 9. Client-side considerations regarding duplicate notifications
- Chapter 9. Priority
- Chapter 9. Search
- Chapter 9. Monitoring and alerting
- Chapter 9. Availability monitoring and alerting on the notification/alerting service
- Chapter 9. Other possible discussion topics
- Chapter 9. Final notes
- Chapter 9. Summary
- Chapter 10. Design a database batch auditing service
- Chapter 10. Defining a validation with a conditional statement on a SQL query’s result
- Chapter 10. A simple SQL batch auditing service
- Chapter 10. Requirements
- Chapter 10. High-level architecture
- Chapter 10. Constraints on database queries
- Chapter 10. Prevent too many simultaneous queries
- Chapter 10. Other users of database schema metadata
- Chapter 10. Auditing a data pipeline
- Chapter 10. Logging, monitoring, and alerting
- Chapter 10. Other possible types of audits
- Chapter 10. Other possible discussion topics
- Chapter 10. References
- Chapter 10. Summary
- Chapter 11. Autocomplete/typeahead
- Chapter 11. Search vs. autocomplete
- Chapter 11. Functional requirements
- Chapter 11. Non-functional requirements
- Chapter 11. Planning the high-level architecture
- Chapter 11. Weighted trie approach and initial high-level architecture
- Chapter 11. Detailed implementation
- Chapter 11. Sampling approach
- Chapter 11. Handling storage requirements
- Chapter 11. Handling phrases instead of single words
- Chapter 11. Logging, monitoring, and alerting
- Chapter 11. Other considerations and further discussion
- Chapter 11. Summary
- Chapter 12. Design Flickr
- Chapter 12. Non-functional requirements
- Chapter 12. High-level architecture
- Chapter 12. SQL schema
- Chapter 12. Organizing directories and files on the CDN
- Chapter 12. Uploading a photo
- Chapter 12. Downloading images and data
- Chapter 12. Monitoring and alerting
- Chapter 12. Some other services
- Chapter 12. Other possible discussion topics
- Chapter 12. Summary
- Chapter 13. Design a Content Distribution Network
- Chapter 13. Requirements
- Chapter 13. CDN authentication and authorization
- Chapter 13. High-level architecture
- Chapter 13. Storage service
- Chapter 13. Common operations
- Chapter 13. Cache invalidation
- Chapter 13. Logging, monitoring, and alerting
- Chapter 13. Other possible discussions on downloading media files
- Chapter 13. Summary
- Chapter 14. Design a text messaging app
- Chapter 14. Initial thoughts
- Chapter 14. Initial high-level design
- Chapter 14. Connection service
- Chapter 14. Sender service
- Chapter 14. Message service
- Chapter 14. Message-sending service
- Chapter 14. Search
- Chapter 14. Logging, monitoring, and alerting
- Chapter 14. Other possible discussion topics
- Chapter 14. Summary
- Chapter 15. Design Airbnb
- Chapter 15. Design decisions
- Chapter 15. High-level architecture
- Chapter 15. Functional partitioning
- Chapter 15. Create or update a listing
- Chapter 15. Approval service
- Chapter 15. Booking service
- Chapter 15. Availability service
- Chapter 15. Logging, monitoring, and alerting
- Chapter 15. Other possible discussion topics
- Chapter 15. Summary
- Chapter 16. Design a news feed
- Chapter 16. High-level architecture
- Chapter 16. Prepare feed in advance
- Chapter 16. Validation and content moderation
- Chapter 16. Logging, monitoring, and alerting
- Chapter 16. Other possible discussion topics
- Chapter 16. Summary
- Chapter 17. Design a dashboard of top 10 products on Amazon by sales volume
- Chapter 17. Initial thoughts
- Chapter 17. Initial high-level architecture
- Chapter 17. Aggregation service
- Chapter 17. Batch pipeline
- Chapter 17. Streaming pipeline
- Chapter 17. Approximation
- Chapter 17. Dashboard with Lambda architecture
- Chapter 17. Kappa architecture approach
- Chapter 17. Logging, monitoring, and alerting
- Chapter 17. Other possible discussion topics
- Chapter 17. References
- Chapter 17. Summary
- Appendix A. Monoliths vs. microservices
- Appendix A. Disadvantages of monoliths
- Appendix A. Advantages of services
- Appendix A. Disadvantages of services
- Appendix A. References
- Appendix B. OAuth 2.0 authorization and OpenID Connect authentication
- Appendix B. Prelude: Simple login, cookie-based authentication
- Appendix B. Single sign-on
- Appendix B. Disadvantages of simple login
- Appendix B. OAuth 2.0 flow
- Appendix B. Other OAuth 2.0 flows
- Appendix B. OpenID Connect authentication
- Appendix C. C4 Model
- Appendix D. Two-phase commit (2PC)
Discover more from Expert Training
Subscribe to get the latest posts sent to your email.