About This Course
Serverless computing has fundamentally changed the way organisations build and operate software. By abstracting away server management, platforms such as AWS Lambda and Azure Functions allow development teams to focus entirely on business logic — deploying code that scales automatically, costs only what it consumes, and integrates seamlessly with dozens of managed cloud services. For organisations seeking to modernise their technology stack, reduce operational overhead, and accelerate time to market, serverless is no longer an emerging option; it is a strategic imperative.
This ten-day programme from TrainingComplex provides a comprehensive, hands-on journey through serverless computing on both Amazon Web Services and Microsoft Azure. Participants will move from foundational concepts through to advanced production patterns, gaining the confidence to architect resilient, cost-efficient, and observable serverless systems. The curriculum is structured to build knowledge progressively — starting with the serverless paradigm itself, then diving deep into each platform's tooling, event sources, security controls, monitoring capabilities, and deployment pipelines.
A dual-platform approach is deliberately chosen because most enterprises operate in multi-cloud or hybrid environments. Understanding the similarities and differences between AWS Lambda and Azure Functions gives architects and developers the flexibility to select the right tool for each workload, avoid vendor lock-in, and communicate effectively across cloud teams. Real-world case studies, guided lab exercises, and a capstone project ensure that learning translates directly into on-the-job capability.
By the end of the programme, delegates will be equipped not only to write and deploy serverless functions but also to design entire event-driven systems, implement robust CI/CD pipelines for serverless workloads, apply security and compliance controls at every layer, and optimise performance and cost at scale. Whether your organisation is cloud-native or beginning its migration journey, this course delivers the technical depth and practical confidence needed to lead serverless initiatives with authority.
Who Should Attend
- Software Developers and Backend Engineers transitioning to cloud-native or serverless architectures
- Cloud Architects and Solutions Architects designing event-driven or microservices-based systems
- DevOps and Platform Engineers responsible for CI/CD pipelines and cloud infrastructure
- Full-Stack Developers looking to extend their capabilities into serverless application design
- Tech Leads and Engineering Managers overseeing cloud modernisation projects
- IT Professionals with existing cloud exposure seeking structured, platform-specific serverless expertise
Learning Objectives
- Explain the serverless computing paradigm and its architectural, operational, and economic advantages over traditional infrastructure models
- Set up and configure development environments for both AWS Lambda and Azure Functions using official SDKs, CLIs, and local emulation tools
- Write, test, and deploy serverless functions in multiple runtimes including Node.js, Python, and C# across both platforms
- Design and implement event-driven architectures using triggers such as HTTP, messaging queues, storage events, timers, and streaming data sources
- Integrate AWS Lambda with core AWS services including API Gateway, DynamoDB, S3, SNS, SQS, EventBridge, and Step Functions
- Integrate Azure Functions with core Azure services including API Management, Cosmos DB, Blob Storage, Service Bus, Event Grid, and Durable Functions
- Apply identity, access, and secrets management best practices to secure serverless workloads on both platforms
- Build and maintain automated CI/CD pipelines for serverless applications using tools such as AWS SAM, Serverless Framework, and Azure DevOps
- Monitor, trace, and debug serverless functions using AWS CloudWatch, X-Ray, Azure Monitor, and Application Insights
- Optimise serverless functions for cold start latency, memory allocation, concurrency limits, and cost efficiency
- Implement error handling, retry logic, dead-letter queues, and idempotency patterns for production-grade reliability
- Compare platform capabilities to make informed multi-cloud architecture decisions and avoid vendor lock-in
- Deliver a fully functional, production-ready serverless application as a capstone project integrating skills from both platforms
Course Modules
Module 1: The Serverless Paradigm: Concepts, Benefits, and Trade-Offs
- Evolution from monoliths to microservices to serverless and the forces driving adoption
- Core characteristics of serverless: statelessness, event-driven execution, and consumption-based billing
- When serverless is the right choice and when it is not: workload fit analysis
- Overview of the AWS Lambda and Azure Functions ecosystems and positioning within each cloud
- Responsibility boundaries in serverless: understanding the shared responsibility model and what the provider abstracts away
- Total cost of ownership comparison: serverless vs. containerised vs. VM-based workloads across different traffic profiles
Module 2: Setting Up Your Serverless Development Environment
- Installing and configuring the AWS CLI, SAM CLI, and Lambda local emulation with AWS SAM Local
- Configuring the Azure CLI, Azure Functions Core Tools, and local runtime emulation with Azurite
- IDE setup, extensions, and debugging configurations for VS Code on both platforms
- Version control integration with Git and project scaffolding conventions for serverless repositories
- Managing multiple AWS profiles and Azure subscriptions locally to support multi-environment development workflows
- Dependency management strategies: using virtual environments for Python, node_modules isolation, and NuGet package resolution in serverless projects
Module 3: Writing and Deploying Your First Functions
- Anatomy of an AWS Lambda function: handler signature, context object, and execution environment lifecycle
- Anatomy of an Azure Function: function.json bindings, host.json configuration, and execution model
- Deploying functions via the console, CLI, and infrastructure-as-code templates on both platforms
- Runtime selection and language support: Node.js, Python, and C# across AWS and Azure
- Packaging and dependency bundling: Lambda deployment packages and zip vs. container image formats compared with Azure Functions zip deploy and container support
- Using Lambda Layers and Azure Functions extension bundles to share common libraries across multiple functions without duplicating package size
Module 4: Event Sources and Triggers on AWS Lambda
- HTTP triggers with Amazon API Gateway: REST vs. HTTP APIs, routing, and authorisers
- Asynchronous invocation with Amazon SQS, SNS, and EventBridge event rules
- Stream-based triggers using Amazon Kinesis and DynamoDB Streams for real-time data processing
- Scheduled execution with EventBridge rules and S3 object event notifications
- Lambda function URLs as a lightweight HTTP endpoint alternative to API Gateway for single-function exposure scenarios
- Configuring batch size, bisect-on-error, and maximum retry attempts for SQS and Kinesis trigger sources to control throughput and failure isolation
Module 5: Event Sources and Triggers on Azure Functions
- HTTP-triggered functions and integration with Azure API Management for production-grade API design
- Message-driven triggers using Azure Service Bus queues and topics for reliable async processing
- Event Grid subscriptions and Blob Storage triggers for reactive, storage-event-driven workflows
- Timer triggers for scheduled jobs and Cosmos DB change feed triggers for database-driven automation
- Using Azure Event Hubs triggers for high-throughput streaming ingestion scenarios and configuring consumer group isolation per function app
- Configuring trigger concurrency, prefetch counts, and lock duration settings in host.json to tune throughput and backpressure behaviour
Module 6: Integrating Serverless Functions with Managed Cloud Services
- AWS Lambda integrations: reading and writing to DynamoDB, S3 operations, and publishing to SNS topics
- Azure Functions integrations: Cosmos DB input and output bindings, Blob Storage access, and Service Bus messaging
- Using environment variables, AWS Systems Manager Parameter Store, and Azure App Configuration for dynamic configuration
- Connecting serverless functions to relational databases using RDS Proxy on AWS and Azure SQL with managed identity
- Implementing output binding fan-out patterns: writing a single function invocation result simultaneously to multiple downstream services using Azure binding expressions
- Managing SDK client initialisation outside the handler to reuse connections across warm invocations and reduce per-request latency on both platforms
Module 7: Orchestrating Serverless Workflows
- Introduction to AWS Step Functions: state machine concepts, standard vs. express workflows, and use cases
- Building Azure Durable Functions: orchestrator, activity, and entity functions and the fan-out/fan-in pattern
- Error handling and compensation logic in multi-step workflows on both platforms
- Choosing between direct function chaining and orchestration services based on complexity and latency requirements
- Implementing the saga pattern in serverless workflows: coordinating distributed transactions with compensating steps across AWS Step Functions and Durable Functions
- Versioning and evolving long-running orchestrations safely: strategies for deploying changes without corrupting in-flight workflow instances on both platforms
Module 8: Security and Identity Management for Serverless Workloads
- AWS IAM roles for Lambda: execution roles, resource-based policies, and least-privilege design principles
- Azure managed identities for Functions: system-assigned vs. user-assigned identities and RBAC assignments
- Secrets management with AWS Secrets Manager and Azure Key Vault: retrieval patterns and rotation strategies
- Network security controls: Lambda VPC integration, Azure Functions VNet integration, and private endpoints
- Validating and sanitising event payloads at the function boundary: defending against injection attacks and malformed input in HTTP and message-driven triggers
- Auditing serverless workloads with AWS CloudTrail and Azure Monitor activity logs: correlating function invocations with control-plane changes for compliance reporting
Module 9: Observability: Monitoring, Logging, and Distributed Tracing
- Structured logging best practices and CloudWatch Logs Insights queries for Lambda function analysis
- Azure Monitor and Log Analytics workspaces: querying function telemetry with Kusto Query Language
- Distributed tracing with AWS X-Ray: instrumentation, service maps, and latency analysis for Lambda chains
- Application Insights for Azure Functions: live metrics, dependency tracking, and custom telemetry events
- Defining and tracking business-level custom metrics: publishing CloudWatch custom metrics from Lambda and custom measurements via the Application Insights SDK in Azure
- Building actionable alerting policies: configuring CloudWatch composite alarms for Lambda error and throttle rates and Azure Monitor alert rules with dynamic thresholds for function failure rates
Module 10: CI/CD Pipelines for Serverless Applications
- Infrastructure-as-code for Lambda: authoring and deploying AWS SAM templates with nested stacks
- Azure Resource Manager and Bicep templates for repeatable Azure Functions deployments
- Building serverless CI/CD pipelines with GitHub Actions: test, lint, package, and deploy stages
- Using the Serverless Framework as a cross-platform abstraction: plugins, stages, and environment promotion
- Implementing canary and linear traffic-shifting deployments for Lambda aliases using AWS CodeDeploy and automated rollback on CloudWatch alarm breach
- Managing pipeline secrets securely: injecting AWS credentials via OIDC federation and Azure service principal credentials via GitHub Actions environment secrets without storing long-lived keys
Module 11: Performance Optimisation and Cost Management
- Understanding and mitigating cold starts: provisioned concurrency on Lambda and Premium plan on Azure Functions
- Memory and timeout tuning: profiling function execution and right-sizing resource allocation on both platforms
- Concurrency limits, throttling behaviour, and reserved concurrency strategies on AWS and Azure
- Cost modelling and monitoring: AWS Cost Explorer Lambda metrics and Azure Cost Management function consumption analysis
- Reducing cold start duration through runtime-specific optimisation techniques: minimising import surface area in Python, using esbuild tree-shaking in Node.js, and leveraging ReadyToRun compilation in .NET Azure Functions
- Identifying and eliminating billable idle time in orchestrated workflows by restructuring Step Functions state machines and Durable Functions activity chains to minimise wait-state duration
Module 12: Reliability Patterns: Error Handling, Retries, and Idempotency
- Dead-letter queues and failure destinations on AWS Lambda for asynchronous invocation error capture
- Poison message handling in Azure Functions with Service Bus and Blob Storage trigger error quarantine
- Implementing idempotency using DynamoDB conditional writes and Azure Cosmos DB optimistic concurrency
- Circuit breaker and retry patterns in serverless architectures using AWS SDK retry configuration and Polly in .NET Azure Functions
- Designing idempotency keys at the API Gateway and Azure API Management layers to deduplicate client retries before they reach function execution
- Correlating error events across retries using consistent invocation identifiers in structured logs to distinguish transient failures from systematic defects during post-incident analysis
Module 13: Capstone Project: Designing and Delivering a Production-Ready Serverless Application
- Requirements analysis and architecture design: selecting appropriate services, triggers, and orchestration patterns
- Implementation sprint: building, testing, and deploying the full application across chosen cloud platform(s)
- Security review, observability instrumentation, and CI/CD pipeline integration for the capstone solution
- Peer presentation and design defence: articulating trade-offs, platform choices, and lessons learned to the group
- Load and chaos testing the capstone application: simulating concurrency spikes, trigger source failures, and downstream dependency outages to validate reliability patterns under realistic conditions
- Cost and performance retrospective: analysing actual invocation metrics, cold start frequency, and billing data from the deployed capstone to reconcile observed behaviour against the original architecture assumptions
Requirements & Prerequisites
Participants should have working knowledge of at least one programming language such as Python, JavaScript, or C#, and a basic understanding of cloud computing concepts including compute, storage, and networking services. Familiarity with either AWS or Azure at a foundational level — such as having completed a cloud practitioner or fundamentals certification — is strongly recommended. Prior experience with REST APIs and version control using Git will help delegates get the most out of the lab exercises from day one.
Training Methodology
- Guided platform labs on both AWS and Azure environments, with each delegate working on a dedicated cloud sandbox account to execute real deployments
- Incremental coding workshops where participants build a multi-function serverless application piece by piece across the ten days
- Side-by-side platform comparisons using structured worksheets that map equivalent services, patterns, and limitations between AWS Lambda and Azure Functions
- Scenario-based architecture exercises in which small groups design serverless solutions for realistic business problems drawn from finance, healthcare, logistics, and retail sectors
- Live debugging and troubleshooting sessions using AWS X-Ray and Azure Application Insights on intentionally flawed function code
- CI/CD pipeline build-alongs using AWS SAM CLI, Serverless Framework, and Azure DevOps to automate test, package, and deploy workflows
- Security review exercises applying IAM role analysis, secrets scanning, and least-privilege audits to sample serverless architectures
- Capstone project with peer presentation, where each participant or pair delivers a working serverless application and defends their design decisions to the group
Organisational Benefits
- Accelerated cloud modernisation as staff gain immediately applicable serverless skills on the two most widely adopted cloud platforms
- Reduced infrastructure and operational costs through adoption of consumption-based, auto-scaling serverless models
- Faster software delivery cycles enabled by teams confident in serverless CI/CD pipelines and deployment automation
- Improved system resilience and reliability through proper implementation of error handling, retry, and observability patterns
- Stronger multi-cloud capability allowing organisations to distribute workloads strategically across AWS and Azure
- Enhanced security posture through consistent application of IAM, secrets management, and least-privilege principles in serverless environments
- Reduced vendor dependency as architects understand platform trade-offs and can make objective technology choices
- Higher developer productivity as engineers spend less time on infrastructure management and more time delivering business value
Where Is Serverless Computing with AWS Lambda and Azure Functions Training Offered?
This course runs in-person across: Johannesburg, Mombasa, Lagos, Nakuru, Addis Ababa, Zanzibar, Pretoria, Arusha, Abuja, Dubai, Dar es Salaam, Nairobi, Riyadh, Kisumu, Kigali, Kampala, Cape Town, Naivasha, Accra, plus Live Virtual (online) cohorts. Browse live dates for your city below.
Upcoming Schedules
| Location | Format | Dates | Price |
|---|
| Johannesburg, South Africa |
In-Person |
5 Oct 2026 – 16 Oct 2026 |
USD 7,000 |
| Mombasa, Kenya |
In-Person |
5 Oct 2026 – 16 Oct 2026 |
KES 230,000 |
| Lagos, Nigeria |
In-Person |
12 Oct 2026 – 23 Oct 2026 |
USD 5,000 |
| Nakuru, Kenya |
In-Person |
12 Oct 2026 – 23 Oct 2026 |
KES 230,000 |
| Live Virtual |
Online |
17 Oct 2026 – 6 Dec 2026 |
KES 160,000 |
| Addis Ababa, Ethiopia |
In-Person |
19 Oct 2026 – 28 Oct 2026 |
USD 4,800 |
| Zanzibar, Tanzania |
In-Person |
19 Oct 2026 – 28 Oct 2026 |
USD 5,000 |
| Pretoria, South Africa |
In-Person |
19 Oct 2026 – 28 Oct 2026 |
USD 6,600 |
| Arusha, Tanzania |
In-Person |
19 Oct 2026 – 28 Oct 2026 |
USD 4,200 |
| Abuja, Nigeria |
In-Person |
19 Oct 2026 – 28 Oct 2026 |
USD 5,600 |
| Dubai, United Arab Emirates |
In-Person |
19 Oct 2026 – 28 Oct 2026 |
USD 8,200 |
| Dar es Salaam, Tanzania |
In-Person |
19 Oct 2026 – 30 Oct 2026 |
USD 4,600 |
| Live Virtual |
Online |
19 Oct 2026 – 28 Oct 2026 |
KES 160,000 |
| Nairobi, Kenya |
In-Person |
19 Oct 2026 – 28 Oct 2026 |
KES 230,000 |
| Riyadh, Saudi Arabia |
In-Person |
19 Oct 2026 – 30 Oct 2026 |
USD 9,000 |
+237 more dates — view live schedule →
Frequently Asked Questions
Do I need accounts on both AWS and Azure before the course begins?
TrainingComplex provides dedicated sandbox accounts on both AWS and Azure for use throughout the programme, so you do not need to bring your own paid accounts. You will need a laptop with internet access and the ability to install the required CLIs and VS Code extensions, which the pre-course setup guide will walk you through.
Which programming language is used in the lab exercises?
The majority of labs are delivered in Python and Node.js, as these runtimes are supported natively on both AWS Lambda and Azure Functions and are the most commonly used in enterprise serverless environments. C# examples are also demonstrated for Azure Functions. Participants comfortable in any of these languages will be able to follow along fully.
Will I receive a certificate upon completion?
Yes. Delegates who attend all sessions and complete the capstone project will receive a TrainingComplex Certificate of Completion in Serverless Computing with AWS Lambda and Azure Functions. This certificate is issued digitally and can be shared on professional profiles such as LinkedIn.
Does this course prepare me for AWS or Azure certification exams?
While this course is not a certification exam preparation programme, the content aligns closely with topics covered in the AWS Certified Developer – Associate and the Microsoft Certified: Azure Developer Associate examinations. Many participants find that completing this course significantly strengthens their readiness for those certifications.
Is prior serverless experience required to attend?
No prior serverless experience is needed. The programme begins from first principles and builds progressively. However, participants should be comfortable writing code in at least one supported language and have a basic familiarity with cloud services, as the course moves quickly into hands-on implementation from the first day.
