NodeJS Advanced Topics Syllabus

Advanced Topics syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Advanced Topics in NodeJS, not a summary of it.

1. 1

   Microservices

   3 topics

   • Introduction to Microservices
   • Building Microservices with NodeJS
   • Service Discovery
2. 2

   GraphQL

   3 topics

   • Introduction to GraphQL
   • Setting Up GraphQL Server
   • Integrating with Express
3. 3

   Serverless Architecture

   3 topics

   • Introduction to Serverless
   • AWS Lambda
   • Serverless Framework

Advanced Topics flashcards for NodeJS

24 of 51 cards from the Advanced Topics deck — real questions with worked answers.

1. What is a microservices architecture?

   An architectural style that structures an application as a collection of small, independently deployable services, each running in its own process and communicating over lightweight mechanisms (typically HTTP/REST or messaging), organized around business capabilities.

2. How does a monolithic architecture differ from a microservices architecture?

   A monolith is a single deployable unit where all functionality shares one codebase and process; microservices split functionality into many small, independently deployable and independently scalable services that communicate over the network.

3. List three key benefits of microservices.

   Independent deployability (deploy one service without redeploying the whole app), independent/technology-agnostic scalability, fault isolation, and freedom to use different tech stacks per service.

4. Name three common drawbacks or challenges of microservices.

   Operational complexity (many services to deploy/monitor), network latency and unreliability between services, distributed data management and eventual consistency, and harder end-to-end testing/debugging.

5. In microservices, what is the difference between synchronous and asynchronous communication?

   Synchronous communication (e.g., HTTP/REST, gRPC) blocks the caller until a response returns; asynchronous communication (e.g., message queues/event brokers like RabbitMQ or Kafka) lets the sender continue without waiting, improving decoupling and resilience.

6. What does 'each microservice owns its own database' (database-per-service) mean and why is it used?

   Each service has a private data store that only it can access directly; this enforces loose coupling and lets each service choose the best storage technology, at the cost of needing cross-service data coordination via APIs or events.

7. What is an API Gateway in a microservices system?

   A single entry point that sits in front of the services and handles cross-cutting concerns like routing requests to the right service, authentication, rate limiting, load balancing, and response aggregation.

8. Which NodeJS frameworks are commonly used to build individual microservices?

   Express, Fastify, NestJS, Koa, and Hapi are commonly used to build the HTTP/REST endpoints of NodeJS microservices.

9. When building a NodeJS microservice, why are environment variables (e.g., via process.env or dotenv) important?

   They externalize configuration (ports, database URLs, secrets, service endpoints) so the same code runs in different environments, following the config principle of the Twelve-Factor App methodology.

10. In NodeJS microservices, what is a health check endpoint and why is it needed?

    A lightweight endpoint (commonly GET /health or /healthz) that returns the service's status; orchestrators and load balancers poll it to determine whether the instance is alive and ready to receive traffic.

11. What role does Docker typically play in deploying NodeJS microservices?

    Docker packages each service with its dependencies into a portable container image, giving consistent environments across dev/test/prod and enabling orchestration with tools like Kubernetes or Docker Compose.

12. What is service discovery in a microservices architecture?

    The mechanism by which services automatically find the network locations (host and port) of other services, so instances can be located dynamically without hardcoding addresses.

13. Contrast client-side and server-side service discovery.

    In client-side discovery, the client queries the service registry and picks an instance itself (does its own load balancing). In server-side discovery, the client calls a load balancer/router that queries the registry and forwards the request.

14. What is a service registry?

    A database of available service instances and their network locations; services register on startup and deregister on shutdown, and clients or routers query it to discover instances. Examples: Consul, Eureka, etcd.

15. Name two popular tools used for service discovery.

    Consul (HashiCorp), Netflix Eureka, etcd, Apache ZooKeeper, and Kubernetes' built-in DNS-based service discovery.

16. How does Kubernetes provide service discovery?

    Kubernetes assigns each Service a stable virtual IP and a DNS name; pods reach other services by name (e.g., http://my-service) and kube-proxy load-balances requests across the healthy pods behind that Service.

17. What is the difference between self-registration and third-party registration in service discovery?

    In self-registration, each service instance registers and deregisters itself with the registry. In third-party registration, a separate registrar component (or the platform) detects instances and registers them on their behalf.

18. What is GraphQL?

    A query language for APIs and a runtime for fulfilling those queries, developed by Facebook, that lets clients request exactly the data they need from a single endpoint against a strongly typed schema.

19. Name three ways GraphQL differs from REST.

    GraphQL uses a single endpoint (REST uses many URLs), lets the client specify exactly which fields to return (avoiding over-/under-fetching), and is defined by a strongly typed schema; REST typically returns fixed resource representations.

20. What is over-fetching and under-fetching, and how does GraphQL address them?

    Over-fetching is receiving more data than needed; under-fetching is needing multiple requests to gather related data. GraphQL solves both by letting the client request precisely the fields it wants in one query.

21. What are the three root operation types in GraphQL?

    Query (read data), Mutation (write/modify data), and Subscription (receive real-time updates, typically over WebSockets).

22. What is a GraphQL schema?

    A strongly typed contract, written in the Schema Definition Language (SDL), that defines the types, fields, and root operations (Query, Mutation, Subscription) the API exposes.

23. What is a resolver in GraphQL?

    A function that returns the value for a particular field in the schema; GraphQL calls resolvers to fetch or compute the data for each requested field.

24. What arguments does a GraphQL resolver function receive?

    Four arguments: parent (the result of the parent field), args (the field's arguments), context (shared per-request data like auth/DB connections), and info (query AST/execution metadata).

See more Advanced Topics flashcards →

Planning Advanced Topics for NodeJS

Advanced Topics (NodeJS) FAQ