Backend Development Testing, DevOps and Deployment Syllabus

Testing, DevOps and Deployment syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Testing, DevOps and Deployment in Backend Development, not a summary of it.

1. 1

   Testing Strategies

   5 topics

   • Unit Testing
   • Integration Testing
   • End-to-End and API Testing
   • Mocking and Test Doubles
   • Test-Driven Development
2. 2

   Containerization

   3 topics

   • Docker Fundamentals
   • Container Registries
   • Kubernetes Basics
3. 3

   CI/CD Pipelines

   4 topics

   • Continuous Integration
   • Continuous Delivery and Deployment
   • Pipeline Tools
   • Deployment Strategies
4. 4

   Cloud Platforms and Serverless

   4 topics

   • Cloud Providers (AWS, GCP, Azure)
   • Compute, Storage and Networking Services
   • Serverless Functions
   • Infrastructure as Code
5. 5

   Observability and Monitoring

   5 topics

   • Logging and Structured Logs
   • Metrics and Dashboards
   • Application Performance Monitoring
   • Alerting and Incident Response
   • Health Checks and Readiness Probes
6. 6

   Performance and Reliability Engineering

   4 topics

   • Load and Stress Testing
   • Profiling and Bottleneck Analysis
   • Graceful Degradation and Retries
   • Service Level Objectives (SLO/SLA)

Testing, DevOps and Deployment flashcards for Backend Development

23 of 50 cards from the Testing, DevOps and Deployment deck — real questions with worked answers.

1. What is a unit test, and what is its defining scope?

   A unit test verifies the smallest testable piece of code (typically a single function, method, or class) in isolation from its dependencies. It should be fast, deterministic, and test one behavior at a time.

2. What are the three phases of the Arrange-Act-Assert (AAA) pattern in a unit test?

   Arrange: set up the object under test and its inputs/dependencies. Act: invoke the method or behavior being tested. Assert: verify the actual result matches the expected outcome.

3. How does integration testing differ from unit testing?

   Integration testing verifies that multiple components (e.g., service + database, or two modules) work correctly together, exercising real interactions and interfaces. Unit tests isolate one component and mock its collaborators.

4. What is the 'test pyramid' and what does it recommend about test proportions?

   A model prescribing many fast, cheap unit tests at the base, fewer integration tests in the middle, and very few slow, expensive end-to-end tests at the top, to balance speed, cost, and confidence.

5. What does an end-to-end (E2E) test validate?

   It validates a complete user workflow through the entire deployed system (UI, backend, database, external services) as a real user would experience it, confirming all layers integrate correctly.

6. In API testing, what do the HTTP status code classes 2xx, 4xx, and 5xx signify?

   2xx = success (e.g., 200 OK, 201 Created); 4xx = client error (e.g., 400 Bad Request, 401 Unauthorized, 404 Not Found); 5xx = server error (e.g., 500 Internal Server Error, 503 Service Unavailable).

7. What is contract testing in the context of API testing?

   A technique verifying that the messages exchanged between a service consumer and provider conform to a shared contract (agreed request/response schema), catching integration breakages without full E2E tests.

8. Define the five categories of test doubles per Gerard Meszaros.

   Dummy: passed but never used; Stub: returns canned answers to calls; Spy: a stub that records how it was called; Mock: pre-programmed with expectations and verifies interactions; Fake: a working but simplified implementation (e.g., in-memory DB).

9. What is the key behavioral difference between a stub and a mock?

   A stub provides canned responses to enable the test (state verification); a mock additionally has expectations about which calls should occur and fails the test if they are not met (behavior verification).

10. What is 'mocking' and why is it used?

    Replacing a real dependency with a controlled substitute so the unit under test can be exercised in isolation, deterministically, and without slow or side-effecting external systems (databases, networks, APIs).

11. What is the Red-Green-Refactor cycle of Test-Driven Development (TDD)?

    Red: write a failing test for desired behavior. Green: write the minimal code to make it pass. Refactor: clean up the code while keeping all tests passing. Repeat.

12. In TDD, what is the strict rule about writing production code?

    You may not write production code until you have a failing test that requires it; you write only enough production code to make the failing test pass.

13. What is code coverage, and why is high coverage not equivalent to good testing?

    Code coverage is the percentage of code (lines/branches/statements) executed by tests. High coverage only confirms code ran, not that assertions meaningfully verify correctness, so it can be high while tests are weak.

14. What is the difference between line coverage and branch coverage?

    Line (statement) coverage measures which lines executed; branch coverage measures whether every possible outcome of each decision point (e.g., both the true and false paths of an if) was taken. Branch coverage is stricter.

15. What is a Docker image versus a Docker container?

    An image is a read-only, layered template containing an app and its dependencies. A container is a runnable, isolated instance of an image with a writable layer added on top at runtime.

16. What is a Dockerfile and what does the FROM instruction do?

    A Dockerfile is a text script of instructions to build an image. FROM specifies the base image that subsequent layers are built upon; it is (except for scratch) the first instruction.

17. What is the benefit of a multi-stage Docker build?

    It uses multiple FROM stages so build tools and intermediate artifacts stay in earlier stages, and only the needed runtime artifacts are copied into a small final image, producing smaller and more secure images.

18. What is the difference between the CMD and ENTRYPOINT instructions in a Dockerfile?

    ENTRYPOINT defines the fixed executable that always runs; CMD provides default arguments (or a default command) that can be overridden at 'docker run'. Combined, ENTRYPOINT is the command and CMD supplies default args.

19. What is a container registry, and name three common examples.

    A container registry is a storage and distribution system for container images (repositories of tagged images). Examples: Docker Hub, Amazon ECR, Google Artifact Registry, Azure Container Registry, GitHub Container Registry (GHCR).

20. What does an image tag like 'myapp:1.2.0' identify, and why avoid relying on 'latest'?

    The part after the colon is the tag, identifying a specific image version. 'latest' is just a mutable default tag that can point to different images over time, causing non-reproducible, unpredictable deployments.

21. In Kubernetes, what is a Pod?

    The smallest deployable unit in Kubernetes: one or more tightly coupled containers that share the same network namespace (IP/port space) and storage volumes, and are scheduled together on a node.

22. What is the role of a Kubernetes Deployment?

    A controller that manages a ReplicaSet to maintain a desired number of Pod replicas and enables declarative updates, rolling updates, and rollbacks of the application's Pods.

23. What is a Kubernetes Service and why is it needed?

    A stable network abstraction (fixed virtual IP/DNS name) that load-balances traffic to a dynamic set of Pods selected by labels, decoupling clients from ephemeral Pod IPs.

See more Testing, DevOps and Deployment flashcards →

Planning Testing, DevOps and Deployment for Backend Development

Testing, DevOps and Deployment (Backend Development) FAQ