Practice : Serverless Architecture

Purpose and Strategic Importance

Serverless Architecture enables teams to build and run applications without managing infrastructure. Developers write business logic, and the cloud provider handles provisioning, scaling, and maintenance - reducing operational overhead and accelerating time-to-market.

This architectural model improves developer productivity, enhances scalability, and allows cost-effective delivery of event-driven, API-first, and data-centric workloads.

Description of the Practice

  • Code is executed in stateless, ephemeral functions (e.g. AWS Lambda, Azure Functions, Google Cloud Functions).
  • Resources such as storage, queues, and databases are provisioned as fully managed services.
  • Functions scale automatically based on demand and pricing is typically pay-per-use.
  • Serverless platforms are integrated with event sources like HTTP triggers, cloud events, or schedule-based invocations.
  • Infrastructure is defined as code for reproducibility and automated deployment.

How to Practise It (Playbook)

1. Getting Started

  • Identify a low-risk service or event-driven task suitable for serverless (e.g. webhook handler, data transformer).
  • Choose a platform and set up your function using frameworks like Serverless Framework, AWS SAM, or Azure Bicep.
  • Define triggers, outputs, and environment configuration using Infrastructure as Code (IaC).
  • Deploy to a dev environment and test with real-world events.

2. Scaling and Maturing

  • Apply serverless for full user-facing workflows, APIs, or background tasks.
  • Manage secrets, identity, and monitoring with cloud-native tools.
  • Implement observability with tracing, logs, and metrics across serverless and downstream services.
  • Establish policies for timeout, memory, retries, and dead-letter queues.
  • Automate provisioning and promotion through CI/CD pipelines.

3. Team Behaviours to Encourage

  • Prioritise business value delivery over infrastructure tinkering.
  • Adopt small, single-responsibility functions for composability and clarity.
  • Share learning and templates to reduce duplication and onboarding friction.
  • Design for statelessness, concurrency, and failure recovery.

4. Watch Out For…

  • Cold start latency affecting performance for critical paths.
  • Vendor lock-in due to proprietary APIs and platform constraints.
  • Monitoring blind spots or lack of integration with broader observability.
  • Spaghetti architectures from unstructured function proliferation.

5. Signals of Success

  • Teams deliver new features faster with fewer infrastructure concerns.
  • Applications scale automatically with minimal manual effort.
  • Costs are aligned to actual usage, with low idle overhead.
  • Serverless workloads are observable, resilient, and reliable.
  • Architecture enables experimentation and reduces time-to-value.