Cloud Computing Serverless and Application Services Syllabus

Serverless and Application Services syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Serverless and Application Services in Cloud Computing, not a summary of it.

1. 1

   Function as a Service

   4 topics

   • FaaS Platforms
   • Triggers and Event Sources
   • Cold Starts and Performance
   • Concurrency and Limits
2. 2

   Serverless Application Patterns

   4 topics

   • Backend-for-Frontend (BFF)
   • Fan-Out and Aggregation
   • Step Functions and Workflow Orchestration
   • Serverless Cost and Trade-offs
3. 3

   API Management

   3 topics

   • REST and GraphQL APIs
   • API Gateway Features
   • API Versioning and Documentation
4. 4

   Application Integration Services

   4 topics

   • Managed Message Queues (SQS, Service Bus)
   • Notification Services (SNS, Pub/Sub)
   • Event Buses and EventBridge
   • Workflow Orchestration

Serverless and Application Services flashcards for Cloud Computing

23 of 50 cards from the Serverless and Application Services deck — real questions with worked answers.

1. What is Function-as-a-Service (FaaS)?

   A serverless compute model where developers deploy individual functions that run in response to events. The provider fully manages provisioning, scaling, and infrastructure; you are billed only for actual execution time, not idle capacity.

2. Name the major FaaS platforms and their cloud providers.

   AWS Lambda (AWS), Azure Functions (Microsoft Azure), Google Cloud Functions / Cloud Run functions (GCP), and Cloudflare Workers (Cloudflare, V8-isolate based).

3. In serverless, what does 'stateless' mean and why does it matter?

   Each function invocation is independent and retains no guaranteed in-memory state between calls. Persistent state must be stored externally (database, cache, object store) because instances can be created or destroyed at any time.

4. What is a trigger (event source) in a FaaS platform?

   A configured event that invokes a function. Examples: HTTP request via API Gateway, object upload to S3/Cloud Storage, message on a queue, database change stream, scheduled timer (cron), or a pub/sub notification.

5. Distinguish push-based from poll-based (pull) event sources in serverless.

   Push-based sources (HTTP, SNS, EventBridge) invoke the function directly when an event occurs. Poll-based sources (SQS, Kinesis, DynamoDB Streams) require the platform to poll the source and batch records to invoke the function.

6. What is a serverless cold start?

   The added latency incurred when a new function instance must be initialized from scratch: downloading code, starting the runtime/container, and running initialization code, because no warm instance is available to serve the request.

7. List the main phases contributing to a cold start.

   1) Provision/download code and container, 2) Start the runtime environment, 3) Run static/init code (e.g., establishing DB connections, loading dependencies) before the handler executes. A warm start skips all of these.

8. Which factors increase cold-start latency?

   Larger deployment package size, heavier runtimes (JVM/.NET vs. Node/Python/Go), more initialization code, VPC/ENI attachment, and more dependencies to load. Provisioned concurrency and lightweight runtimes reduce it.

9. What is provisioned concurrency (AWS Lambda) and what problem does it solve?

   A feature that keeps a set number of function instances pre-initialized and ready to respond immediately, eliminating cold starts for latency-sensitive workloads. You pay for the reserved warm capacity even when idle.

10. Define concurrency in the context of FaaS.

    The number of function instances executing simultaneously at a given moment. Each concurrent request is generally handled by its own instance (one request per instance in AWS Lambda).

11. State the formula relating concurrency to request rate and duration (Little's Law).

    $$\text{Concurrency} = \text{RequestsPerSecond} \times \text{AvgDurationSeconds}$$ For example, $100 \text{ req/s} \times 0.2\text{ s} = 20$ concurrent instances.

12. What is reserved concurrency versus a regional concurrency limit in AWS Lambda?

    The regional limit (default 1000) caps total concurrent executions across all functions in a region. Reserved concurrency carves out a guaranteed portion of that limit for a specific function (also capping that function to it).

13. What happens when a synchronous function invocation exceeds the concurrency limit?

    The invocation is throttled and returns a 429 (TooManyRequests / rate exceeded) error. Asynchronous invocations are retried automatically, and poll-based sources retry based on their configuration.

14. What is the Backend-for-Frontend (BFF) pattern?

    An architectural pattern where a dedicated backend service is built for each specific frontend (e.g., one for web, one for mobile). Each BFF aggregates and tailors downstream API responses to the exact needs of its client.

15. What problem does the BFF pattern solve?

    It avoids a one-size-fits-all API that over- or under-serves clients. Each BFF shapes data, reduces round trips, and handles client-specific concerns (payload size, auth), decoupling frontend evolution from shared backend services.

16. What is the fan-out messaging pattern?

    A single event or message is distributed to multiple consumers/subscribers in parallel, so many processors act on the same event simultaneously. Commonly implemented with SNS-to-SQS or a pub/sub topic with multiple subscribers.

17. Describe the fan-out/fan-in (scatter-gather) pattern.

    Fan-out dispatches work to many parallel workers; fan-in aggregates their individual results back into a single combined result. Used for parallel processing of large jobs, then collecting outputs (e.g., Step Functions Map + aggregation).

18. What is a common serverless implementation of fan-out on AWS?

    Publish a message to an SNS topic that has multiple SQS queues (or Lambda functions) subscribed. Each subscriber receives a copy of the message and processes it independently and in parallel.

19. What are AWS Step Functions?

    A serverless workflow orchestration service that coordinates multiple services/functions into state machines defined in Amazon States Language (JSON). It manages sequencing, branching, parallelism, retries, and error handling.

20. Name common state types in an AWS Step Functions state machine.

    Task (do work), Choice (branching), Parallel (concurrent branches), Map (iterate over a collection), Wait (delay), Pass (transform/pass data), Succeed, and Fail (terminal states).

21. Compare Standard and Express workflows in AWS Step Functions.

    Standard: long-running (up to 1 year), exactly-once, full execution history, priced per state transition. Express: high-volume, short-running (up to 5 min), at-least-once, priced by number and duration of executions; cheaper for high throughput.

22. Contrast orchestration and choreography in workflow design.

    Orchestration uses a central coordinator (e.g., Step Functions) that explicitly directs each step. Choreography has no central controller; services react to events independently via events/messages. Orchestration is easier to monitor; choreography is more loosely coupled.

23. List the main cost components of a FaaS platform like AWS Lambda.

    1) Number of requests (invocations), and 2) Compute duration measured in GB-seconds (allocated memory times execution time). Additional costs may include provisioned concurrency and data transfer.

See more Serverless and Application Services flashcards →

Planning Serverless and Application Services for Cloud Computing

Serverless and Application Services (Cloud Computing) FAQ