Backend Development Architecture, Scalability and Distributed Systems Syllabus

Architecture, Scalability and Distributed Systems syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Architecture, Scalability and Distributed Systems in Backend Development, not a summary of it.

1. 1

   Application Architecture Patterns

   5 topics

   • Layered and Monolithic Architecture
   • Microservices Architecture
   • Service-Oriented Architecture
   • Hexagonal and Clean Architecture
   • Domain-Driven Design Basics
2. 2

   Caching Strategies

   4 topics

   • Cache Levels and CDNs
   • Caching Patterns
   • Redis and Memcached
   • Cache Invalidation and TTLs
3. 3

   Message Queues and Event-Driven Systems

   5 topics

   • Synchronous vs Asynchronous Messaging
   • Message Brokers
   • Publish/Subscribe and Event Streaming
   • Background Jobs and Workers
   • Idempotency and Delivery Guarantees
4. 4

   Scalability and High Availability

   5 topics

   • Horizontal vs Vertical Scaling
   • Load Balancing Strategies
   • Stateless Services and Session Stores
   • Failover and Redundancy
   • CAP Theorem and Consistency Models
5. 5

   Distributed Systems Concepts

   5 topics

   • Eventual Consistency
   • Distributed Transactions and Saga Pattern
   • Service Discovery
   • Circuit Breakers and Resilience
   • Distributed Tracing
6. 6

   System Design

   4 topics

   • Requirements and Capacity Estimation
   • Designing Scalable APIs
   • Data Storage Selection
   • Common System Design Case Studies

Architecture, Scalability and Distributed Systems flashcards for Backend Development

21 of 52 cards from the Architecture, Scalability and Distributed Systems deck — real questions with worked answers.

1. What defines a monolithic architecture?

   An application built and deployed as a single, unified unit where all functional modules (UI, business logic, data access) share one codebase, process, and deployment artifact.

2. In a layered (n-tier) architecture, what is the classic set of layers and the dependency rule?

   Presentation, Business/Application, and Data-Access (persistence) layers. Dependencies flow strictly downward: each layer may call only the layer directly beneath it (or below), never upward.

3. Name two key advantages and two key drawbacks of a monolith.

   Advantages: simple to develop/test/deploy early on, and low operational/latency overhead (in-process calls). Drawbacks: scales only as a whole unit, and a single codebase becomes hard to change and can suffer tight coupling as it grows.

4. What is a microservices architecture?

   An architectural style structuring an application as a suite of small, independently deployable services, each owning its own data and communicating over the network (typically HTTP/REST, gRPC, or messaging).

5. Why should each microservice own its own database (database-per-service)?

   To ensure loose coupling and independent deployability; sharing a database creates hidden coupling. Cross-service data is obtained via APIs or events, not direct table access.

6. Compare monolith vs microservices on deployment and scaling.

   Monolith: one deployable, scaled as a whole (you replicate the entire app). Microservices: many independent deployables, each scaled independently based on its own load.

7. What is Service-Oriented Architecture (SOA) and how does it differ from microservices?

   SOA structures software as coarse-grained, reusable services often integrated through a central Enterprise Service Bus (ESB) with shared governance and data. Microservices are finer-grained, decentralized, share nothing, and use lightweight 'smart endpoints, dumb pipes' communication instead of an ESB.

8. What is an Enterprise Service Bus (ESB) in SOA?

   A central middleware backbone that handles routing, transformation, protocol mediation, and orchestration between services. It centralizes integration logic (a common SOA trait avoided by microservices).

9. What is the core idea of Hexagonal (Ports and Adapters) architecture?

   The application core (domain logic) is isolated from external concerns. It defines ports (interfaces) that adapters implement, so databases, UIs, and external systems plug in at the edges without the core depending on them.

10. In Hexagonal architecture, distinguish a driving (primary) adapter from a driven (secondary) adapter.

    A driving/primary adapter initiates action on the core (e.g., REST controller, CLI). A driven/secondary adapter is called by the core to reach external systems (e.g., database repository, message publisher).

11. State the Dependency Rule in Clean Architecture.

    Source-code dependencies point only inward. Inner circles (entities, use cases) know nothing about outer circles (frameworks, UI, DB); outer layers depend on inner, never the reverse.

12. List the concentric layers of Clean Architecture from innermost to outermost.

    Entities (enterprise business rules) → Use Cases (application business rules) → Interface Adapters (controllers, presenters, gateways) → Frameworks & Drivers (UI, DB, web, external tools).

13. In Domain-Driven Design, what is a Bounded Context?

    An explicit boundary within which a particular domain model and its ubiquitous language are defined and consistent. The same term can mean different things in different bounded contexts.

14. Define Entity vs Value Object in DDD.

    An Entity has a distinct identity that persists over time regardless of attribute changes (e.g., a Customer with an ID). A Value Object has no identity and is defined solely by its attributes; it is immutable and interchangeable (e.g., a Money amount).

15. In DDD, what is an Aggregate and its root?

    An Aggregate is a cluster of entities and value objects treated as a single consistency/transaction unit. The Aggregate Root is the only entry point; external objects reference the aggregate only through the root, which enforces invariants.

16. What is the 'ubiquitous language' in DDD?

    A shared, rigorous vocabulary built jointly by developers and domain experts, used consistently in conversation, code, and models within a bounded context to eliminate translation and ambiguity.

17. What is a Repository in DDD?

    An abstraction that mediates between the domain and data mapping layers, providing a collection-like interface to retrieve and persist aggregates while hiding storage details.

18. List common cache levels from closest to the CPU/client outward.

    CPU caches (L1/L2/L3) → in-process/application memory cache → distributed cache (e.g., Redis) → database/query cache → CDN/edge cache. Each further level is larger but slower/higher-latency.

19. What is a CDN and what problem does it solve?

    A Content Delivery Network is a geographically distributed set of edge servers that cache and serve content close to users, reducing latency, offloading origin servers, and improving availability/throughput for static (and cacheable dynamic) content.

20. Describe the cache-aside (lazy loading) pattern.

    The application checks the cache first; on a miss it reads from the database, then writes the value into the cache before returning it. The cache is populated only on demand, so only requested data is cached.

21. Compare write-through vs write-back (write-behind) caching.

    Write-through: writes go to cache and the datastore synchronously—consistent but higher write latency. Write-back: writes go to cache immediately and are flushed to the datastore asynchronously later—faster writes but risk of data loss if the cache fails before flush.

See more Architecture, Scalability and Distributed Systems flashcards →

Planning Architecture, Scalability and Distributed Systems for Backend Development

Architecture, Scalability and Distributed Systems (Backend Development) FAQ