High Level System Design and Architecture Topics


These are some of the topics that a standard backend engineer should know. Here we are consciously excluding any particular tool, framework or programming language. Instead we want to focus on topics related to high level system design and architecture. It can’t be an exhaustive list ever. I will try my best to keep adding to and please add your items in the comments so that I can include those as well.

  1. Multi-Tenant Architecture
  2. Microservices: A software development technique, a variant of the service-oriented architecture (SOA) architectural style that structures an application as a collection of loosely coupled services. 
  3. Service-Oriented Architecture (SOA)
  4. Web-oriented architecture (WOA): A substyle of service-oriented architecture (SOA) that leverages Web architecture. It emphasizes the generality of interfaces (user interfaces and APIs) via five fundamental generic interface constraints: resource identification (e.g., uniform resource identifier [URI]), manipulation of resources through representations (e.g., HTTP), self-descriptive messages (e.g., Multipurpose Internet Messaging Extensions [MIME] types), hypermedia as the engine of application state (e.g., links) and application neutrality.
  5. Serverless Architecture
  6. Multi-Cloud Architecture
  7. Monolith Systems
  8. High Availability (HA): Active-Active vs Active-Passive design discusses two different ways to achieve HA. Also known as Hot-Hot and Hot-Cold design.
  9. Backpressure
  10. Circuit Breaker
  11. Service Discovery
  12. Green Blue Deployment
  13. Canary
  14. Throughput
  15. Latency
  16. Throttling
  17. API Rate Limiter
  18. CAP theorem
  19. SOLID Design Principles
  20. ACID
  21. SLA vs SLO
  22. Eventual Consistency
  23. Read-after-write-consistency
  24. A/B Testing
  25. Reverse Engineering
  26. Fan-in vs Fan-out
  27. Write-through cache vs Write-around cache
  28. Data co-location
  29. Business Continuity Plan (BCP) 
  30. Disaster Recovery (DR)
  31. Strong Cohesion
  32. Loose Coupling
  33. Idempotency in HTTP Request
  34. Consistent Hashing and DHT
  35. Lazy Loading
  36. Eager Loading
  37. Object Hydration
  38. Pagination
  39. Service Mesh
  40. OpenID Connect
  41. Capacity Planning
  42. Blockchain
  43. Distributed Caching
  44. Load Balancing
  45. Database Sharding
  46. Application Server vs Web Server
  47. Sidecar Design Pattern for Microservices
  48. Synthetic Monitoring
  49. GraphQL API vs REST API
  50. Asynchronous Messaging
  51. Deep Copy vs Shallow Copy
  52. Cloud Computing vs Edge Computing

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.