COURSE FORMAT & DELIVERY DETAILS Fully Self-Paced, On-Demand Access with Lifetime Updates
You begin immediately after enrollment. This course is designed for professionals who demand flexibility without compromise. Once you enrol, you gain full on-demand access to the complete learning platform, with no required schedules, fixed start dates, or time commitments. Learn at your own pace, from anywhere in the world, on any device. - Self-Paced Learning: Progress through the course exactly when and where it suits your schedule. There are no deadlines, no pressure - only structured, proven material that builds your expertise methodically.
- Immediate Online Access: Upon registration, you’ll receive a confirmation email followed by a separate message containing your secure access credentials once your course materials are ready. All content is delivered digitally via a world-class learning portal.
- Lifetime Access: Your enrollment grants permanent, lifelong access to the entire course curriculum. This means you can revisit modules whenever needed, whether for deep review or to re-certify your skills years from now.
- Ongoing Future Updates Included at No Extra Cost: Technology evolves rapidly. That’s why we continuously update this course with the latest enterprise patterns, tools, and best practices. As a student, you receive every enhancement automatically and free of charge - forever.
- 24/7 Global, Mobile-Friendly Access: Whether you're on a desktop, tablet, or smartphone, the platform adapts seamlessly. Study during commutes, between meetings, or from remote locations - your progress syncs across all devices.
Direct Support, Real Expert Guidance
You’re never alone. This course includes ongoing, responsive instructor support from certified serverless architects with real-world enterprise deployment experience. Ask questions, clarify concepts, and receive detailed, practical feedback directly from the experts who designed the curriculum. Verify Your Achievement with a Globally Recognized Certificate
Upon successful completion, you will earn a prestigious Certificate of Completion issued by The Art of Service. This certificate confirms your mastery of serverless architecture at the enterprise level, validating your skills to employers, clients, and industry peers worldwide. The Art of Service is a globally trusted credentialing body, with alumni in over 120 countries and partnerships across IT, cloud, and digital transformation sectors. Zero-Risk Enrollment with Complete Peace of Mind
We remove every barrier to your success. Our commitment is simple: if you follow the program and do not feel it delivers tangible value, you are covered by our strong satisfaction guarantee. Enrol with complete confidence knowing you can request a refund if the course does not meet your expectations. - 100% Money-Back Guarantee: We stand behind the quality and real-world applicability of our content. If you go through the material and feel it hasn’t advanced your skills, you’re eligible for a full refund - no questions asked.
- No Hidden Fees: What you see is what you pay. There are no enrolment surcharges, certification costs, or renewal fees. One transparent price covers everything - access, support, updates, and your official certificate.
- Secure Payment Processing: We accept all major payment methods, including Visa, Mastercard, and PayPal - processed through a PCI-compliant, encrypted gateway to protect your financial information.
- Confirmation & Access Workflow Explained: After enrolment, you’ll receive an email confirmation of your registration. Your access details will be sent separately once your course materials are finalised and ready for delivery - ensuring you begin with a polished, error-free learning experience.
This Works for You - Even If…
You’re concerned this might not fit your background. Let us be clear: this course is built for technical professionals at all levels of cloud exposure, from infrastructure leads to full-stack developers to DevOps engineers. We’ve designed it to meet you where you are. - Even if you’ve only worked with traditional server-based systems, the step-by-step breakdowns will transition you smoothly into serverless paradigms using real enterprise comparisons and migration blueprints.
- Even if you’re time-constrained, the modular structure lets you complete one high-impact lesson in as little as 20 minutes - and apply it the same day.
- Even if you’re not a coding expert, the hands-on implementation guides include annotated configuration templates, IaC scripts, and architecture decision records you can adapt directly to your environment.
Our alumni include senior architects at multinational banks, cloud consultants at global firms, and engineering managers at fast-growing SaaS companies. They trusted this program because it eliminated uncertainty - giving them not just knowledge, but a repeatable, results-driven methodology. This isn’t theoretical. It’s engineered for ROI. Graduates consistently report deploying scalable serverless systems within weeks, reducing operational overhead by 30% to 60%, and gaining recognition for leading transformation initiatives. You’re investing in a career catalyst - with lifetime access, relentless support, guaranteed results, and a credential that signals authority in the modern cloud landscape.
EXTENSIVE & DETAILED COURSE CURRICULUM
Module 1: Foundations of Serverless Architecture - Understanding the shift from monoliths to event-driven systems
- Defining serverless: misconceptions vs. reality
- The evolution of compute: from physical servers to FaaS
- Key characteristics of serverless computing
- Event-driven versus request-driven architectures
- Stateless execution and cold start considerations
- Auto-scaling mechanics and burst capacity planning
- Resource allocation models in serverless environments
- The role of functions in enterprise systems
- Managed services and their impact on operational load
- Cost-efficiency analysis: pay-per-use vs. always-on models
- Vendor lock-in concerns and mitigation strategies
- Serverless in the context of microservices
- When not to use serverless - enterprise anti-patterns
- Architectural trade-offs: latency, observability, governance
- Core principles for resilient serverless design
- Aligning serverless with business agility goals
Module 2: Enterprise Readiness & Governance Frameworks - Serverless maturity model for large organisations
- Establishing governance policies for function deployment
- Function ownership and lifecycle management
- Policy as code for security and compliance
- Multi-account and multi-region deployment strategies
- Role-based access control (RBAC) in serverless contexts
- Compliance frameworks: GDPR, HIPAA, SOC 2 alignment
- Audit trail configuration and log retention policies
- Centralised monitoring and alerting standards
- Cost allocation tagging and chargeback mechanisms
- Change management workflows for serverless components
- Disaster recovery planning for serverless systems
- Backup strategies for stateful dependencies
- Enterprise-ready naming conventions and metadata use
- Policy enforcement using AWS Config, Azure Policy, or GCP Org Policies
- Security posture assessment at scale
- Standardising deployment pipelines across teams
Module 3: Core Serverless Platforms & Provider Deep Dives - AWS Lambda: architecture, limits, and best practices
- Azure Functions: consumption plan vs. premium plan use cases
- Google Cloud Functions and Cloud Run comparisons
- IBM Cloud Functions and Apache OpenWhisk fundamentals
- Alibaba Function Compute for Asia-Pacific deployments
- Oracle Functions and integration with Oracle Cloud Infrastructure
- Comparing cold start performance across providers
- Memory, timeout, and concurrency configurations
- Networking capabilities: VPC, ENI, and egress control
- Runtime support: Node.js, Python, Java, Go, .NET, Rust
- Container-based function packaging: opting into custom runtimes
- Branded managed services: API Gateway, EventBridge, SNS, SQS
- Event sources and polling versus push-based models
- Limits and quotas: understanding and requesting increases
- Regional availability and failover capabilities
- Service-level agreements and uptime guarantees
- Choosing a provider based on enterprise requirements
- Multicloud serverless: feasibility and complexity trade-offs
Module 4: Event-Driven Design & Message Orchestration - Principles of event sourcing and CQRS
- Designing event schemas with schema registries
- Message brokers: Amazon SNS, SQS, EventBridge, Pub/Sub
- Event routing patterns: fan-out, filtering, content-based
- Idempotency and deduplication strategies
- Dead letter queues and error handling workflows
- Message ordering guarantees and limitations
- Event consistency across distributed services
- Event-driven workflows with Step Functions and Logic Apps
- State machines for complex serverless orchestrations
- Human-in-the-loop approvals in automated flows
- Error escalation and retry policies
- Event schema evolution and backward compatibility
- Event mesh architecture for enterprise integration
- Using message headers for tracing and context propagation
- Event storming techniques for domain modelling
- Coupling levels in event-driven systems
- Testing event-driven interactions and integration points
Module 5: Infrastructure as Code & Deployment Automation - Introduction to IaC for serverless systems
- AWS CloudFormation: templates, parameters, and conditions
- Using AWS SAM for simplified serverless deployments
- Serverless Framework: components, plugins, and stages
- Terraform for multicloud serverless provisioning
- Pulumi with TypeScript and Python for modern IaC
- Defining functions, triggers, and permissions as code
- Parameterisation of environment-specific configurations
- Custom resources and provider extensions
- Managing shared layers and dependencies
- Versioning strategies for functions and APIs
- Blue-green deployments for serverless APIs
- Canary releases using API Gateway and weighted routing
- Rollback automation and recovery playbooks
- CI/CD pipelines with GitHub Actions, GitLab CI, Jenkins
- Automated testing in deployment workflows
- Security scanning in pre-deployment gates
- Secrets management: AWS Secrets Manager, HashiCorp Vault
- Environment isolation using stages and accounts
- Drift detection and configuration reconciliation
Module 6: Data Management in Serverless Environments - Choosing databases for serverless: relational vs. NoSQL
- Amazon DynamoDB: throughput modes, GSIs, LSIs
- DynamoDB streams for change data capture
- Time-to-live (TTL) configuration for data lifecycle
- Amazon Aurora Serverless: when to consider it
- Data access patterns and query optimisation
- Connection pooling with RDS Proxy
- Google Cloud Firestore and Firestore in Datastore mode
- Azure Cosmos DB serverless tier
- Eventual consistency challenges and mitigation
- Data validation at ingestion points
- Batch processing with Step Functions and batch windows
- Asynchronous data enrichment pipelines
- Using S3 as a data lake foundation
- S3 event notifications and filtering
- Cross-origin access and bucket policies
- Glue Catalog integration for metadata management
- Data transformation with serverless ETL workflows
- Securing data at rest and in transit
- Compliance for data residency and sovereignty
Module 7: Security, Identity & Access Control - Principle of least privilege in serverless design
- Managing IAM roles and policies for Lambda functions
- Resource-based policies vs. identity-based policies
- Inline policies versus managed policies
- Policy simulation and security validation tools
- Temporary credentials and STS best practices
- Using service-linked roles appropriately
- Securing function URLs and public endpoints
- JWT validation and OAuth2 integration
- Using Amazon Cognito for user management
- Integrating with enterprise identity providers (SAML, OpenID Connect)
- Zero-trust architecture principles applied to serverless
- Network security: VPC, security groups, NACLs
- PrivateLink and interface endpoints for secure access
- Function isolation using VPC attachments
- Logging and monitoring for unauthorised access attempts
- Handling secrets securely in runtime environments
- Audit logging with CloudTrail and Data Events
- Static code analysis for security vulnerabilities
- Runtime protection with AWS GuardDuty and Lambda insights
Module 8: Observability & Real-Time Monitoring - Logs, metrics, and traces: the three pillars of observability
- CloudWatch Logs: log groups, streams, and subscriptions
- Structured logging with JSON formats
- Log filtering and search patterns
- CloudWatch Metrics and custom metric creation
- Alarm configuration for high error rates and latency
- Using CloudWatch Dashboards for real-time visibility
- Distributed tracing with AWS X-Ray
- X-Ray service maps and fault isolation
- Sampling strategies and overhead management
- Correlating traces across services and accounts
- Context propagation using trace headers
- Using OpenTelemetry for vendor-agnostic telemetry
- Exporting metrics to Datadog, New Relic, or Prometheus
- Centralised logging across multiple regions and accounts
- Kinesis Data Firehose for log aggregation
- Alerting workflows with SNS and incident management
- Mean time to detection and resolution benchmarks
- Health checks and synthetic monitoring
- Capacity planning based on execution trends
Module 9: Performance Optimisation & Cost Efficiency - Understanding pricing models: duration, memory, invocations
- Calculating total cost of ownership for serverless systems
- Memory allocation optimisation
- Duration profiling and bottleneck identification
- Provisioned concurrency: cost vs. performance trade-offs
- Managing cold starts with keep-warm strategies
- Function initialisation vs. handling phases
- Dependency bundling and layer optimisation
- Minifying and tree-shaking Node.js packages
- Using lightweight base images for custom runtimes
- Batching requests to reduce invocation counts
- Throttling and retry logic for downstream services
- Auto-scaling concurrency limits and quotas
- Cost allocation and chargeback reporting
- Usage forecasting with AWS Cost Explorer
- Reserved concurrency: when and how to use it
- Monitoring for cost anomalies and alerting
- Cost-aware architecture reviews and approvals
- Right-sizing functions based on historical patterns
- Eliminating idle compute and wasted spend
Module 10: Advanced Serverless Patterns & Anti-Patterns - Sidecar pattern for co-located utilities
- Choreography versus orchestration in workflows
- Message-driven choreography with event buses
- Process managers and saga patterns for distributed transactions
- Compensating actions for rollback logic
- Monorepo vs. polyrepo for function management
- Shared libraries and layer versioning
- Circular dependency identification and refactoring
- Function chaining and its risks
- Fan-out and gather for parallel processing
- Backpressure handling in high-throughput systems
- Rate limiting and quota enforcement at API level
- API versioning and deprecation strategies
- Hybrid architectures: integrating serverless with containers
- Serverless web applications with S3 and CloudFront
- Static site generation with serverless build pipelines
- Real-time applications with WebSockets and API Gateway
- Streaming data processing with Kinesis and Lambda
- Using Lambda for image and file transformations
- Automated document processing workflows
Module 11: Integration with Enterprise Systems - Connecting serverless to legacy backend systems
- Using API proxies for mainframe integration
- Message queue integration with IBM MQ and ActiveMQ
- Event sourcing from relational databases
- Change Data Capture (CDC) with Debezium and Lambda
- Batch-to-real-time transformation strategies
- Integrating with ERP and CRM platforms
- Using serverless for Salesforce and SAP integrations
- Middleware abstraction layers for vendor neutrality
- Business process automation with serverless orchestrators
- Secure hybrid connectivity using Direct Connect and VPN
- On-premises function execution via AWS Outposts
- Edge computing with Lambda@Edge
- Content personalisation at the CDN layer
- Authentication and authorisation across domains
- Data transformation in transit
- Enterprise service bus (ESB) modernisation
- Replacing batch jobs with event-driven triggers
- Master data management in serverless contexts
- Real-time reporting and analytics pipelines
Module 12: Building Serverless APIs & Microservices - REST API design principles for serverless backends
- API Gateway: routes, methods, integrations
- Request validation and schema enforcement
- Custom authorisers and JWT validation
- Usage plans, API keys, and rate limiting
- Stages, deployments, and base path mappings
- Custom domain names and TLS configuration
- GraphQL with AWS AppSync and serverless resolvers
- Resolver mapping templates and VTL
- Data sources: DynamoDB, HTTP, Lambda, RDS
- Real-time subscriptions using WebSockets
- API versioning and backward compatibility
- Documentation generation with OpenAPI specs
- Automated API testing with Postman and Newman
- Canary deployments for API updates
- Throttling and burst protection
- Caching strategies with CloudFront and API Gateway
- Monitoring API health and error rates
- Authentication gateways with Cognito User Pools
- Multi-tenant API patterns with context routing
Module 13: Serverless for Data Engineering & Analytics - Serverless ETL pipelines with Step Functions
- Partitioning strategies for S3 data lakes
- Using Glue for schema inference and ETL jobs
- Athena for serverless SQL querying
- Optimising query performance with partitioning and compression
- Parquet and ORC format advantages
- Automated data validation and quality checks
- Streaming ingestion with Kinesis and Lambda
- Real-time dashboards with QuickSight and Lambda
- Scheduling batch jobs with EventBridge and Cron
- Data lineage tracking with AWS Lake Formation
- Tagging and classification for governance
- Secure access to data for analytics teams
- Cost allocation by department or project
- Alerting on data pipeline failures
- Automated recovery and notification workflows
- Building data APIs for downstream consumers
- Using Lambda to serve model predictions
- Streaming analytics with Kinesis Data Analytics
- Alerting on anomalies in real-time data streams
Module 14: DevOps & SRE Practices for Serverless - Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
Module 1: Foundations of Serverless Architecture - Understanding the shift from monoliths to event-driven systems
- Defining serverless: misconceptions vs. reality
- The evolution of compute: from physical servers to FaaS
- Key characteristics of serverless computing
- Event-driven versus request-driven architectures
- Stateless execution and cold start considerations
- Auto-scaling mechanics and burst capacity planning
- Resource allocation models in serverless environments
- The role of functions in enterprise systems
- Managed services and their impact on operational load
- Cost-efficiency analysis: pay-per-use vs. always-on models
- Vendor lock-in concerns and mitigation strategies
- Serverless in the context of microservices
- When not to use serverless - enterprise anti-patterns
- Architectural trade-offs: latency, observability, governance
- Core principles for resilient serverless design
- Aligning serverless with business agility goals
Module 2: Enterprise Readiness & Governance Frameworks - Serverless maturity model for large organisations
- Establishing governance policies for function deployment
- Function ownership and lifecycle management
- Policy as code for security and compliance
- Multi-account and multi-region deployment strategies
- Role-based access control (RBAC) in serverless contexts
- Compliance frameworks: GDPR, HIPAA, SOC 2 alignment
- Audit trail configuration and log retention policies
- Centralised monitoring and alerting standards
- Cost allocation tagging and chargeback mechanisms
- Change management workflows for serverless components
- Disaster recovery planning for serverless systems
- Backup strategies for stateful dependencies
- Enterprise-ready naming conventions and metadata use
- Policy enforcement using AWS Config, Azure Policy, or GCP Org Policies
- Security posture assessment at scale
- Standardising deployment pipelines across teams
Module 3: Core Serverless Platforms & Provider Deep Dives - AWS Lambda: architecture, limits, and best practices
- Azure Functions: consumption plan vs. premium plan use cases
- Google Cloud Functions and Cloud Run comparisons
- IBM Cloud Functions and Apache OpenWhisk fundamentals
- Alibaba Function Compute for Asia-Pacific deployments
- Oracle Functions and integration with Oracle Cloud Infrastructure
- Comparing cold start performance across providers
- Memory, timeout, and concurrency configurations
- Networking capabilities: VPC, ENI, and egress control
- Runtime support: Node.js, Python, Java, Go, .NET, Rust
- Container-based function packaging: opting into custom runtimes
- Branded managed services: API Gateway, EventBridge, SNS, SQS
- Event sources and polling versus push-based models
- Limits and quotas: understanding and requesting increases
- Regional availability and failover capabilities
- Service-level agreements and uptime guarantees
- Choosing a provider based on enterprise requirements
- Multicloud serverless: feasibility and complexity trade-offs
Module 4: Event-Driven Design & Message Orchestration - Principles of event sourcing and CQRS
- Designing event schemas with schema registries
- Message brokers: Amazon SNS, SQS, EventBridge, Pub/Sub
- Event routing patterns: fan-out, filtering, content-based
- Idempotency and deduplication strategies
- Dead letter queues and error handling workflows
- Message ordering guarantees and limitations
- Event consistency across distributed services
- Event-driven workflows with Step Functions and Logic Apps
- State machines for complex serverless orchestrations
- Human-in-the-loop approvals in automated flows
- Error escalation and retry policies
- Event schema evolution and backward compatibility
- Event mesh architecture for enterprise integration
- Using message headers for tracing and context propagation
- Event storming techniques for domain modelling
- Coupling levels in event-driven systems
- Testing event-driven interactions and integration points
Module 5: Infrastructure as Code & Deployment Automation - Introduction to IaC for serverless systems
- AWS CloudFormation: templates, parameters, and conditions
- Using AWS SAM for simplified serverless deployments
- Serverless Framework: components, plugins, and stages
- Terraform for multicloud serverless provisioning
- Pulumi with TypeScript and Python for modern IaC
- Defining functions, triggers, and permissions as code
- Parameterisation of environment-specific configurations
- Custom resources and provider extensions
- Managing shared layers and dependencies
- Versioning strategies for functions and APIs
- Blue-green deployments for serverless APIs
- Canary releases using API Gateway and weighted routing
- Rollback automation and recovery playbooks
- CI/CD pipelines with GitHub Actions, GitLab CI, Jenkins
- Automated testing in deployment workflows
- Security scanning in pre-deployment gates
- Secrets management: AWS Secrets Manager, HashiCorp Vault
- Environment isolation using stages and accounts
- Drift detection and configuration reconciliation
Module 6: Data Management in Serverless Environments - Choosing databases for serverless: relational vs. NoSQL
- Amazon DynamoDB: throughput modes, GSIs, LSIs
- DynamoDB streams for change data capture
- Time-to-live (TTL) configuration for data lifecycle
- Amazon Aurora Serverless: when to consider it
- Data access patterns and query optimisation
- Connection pooling with RDS Proxy
- Google Cloud Firestore and Firestore in Datastore mode
- Azure Cosmos DB serverless tier
- Eventual consistency challenges and mitigation
- Data validation at ingestion points
- Batch processing with Step Functions and batch windows
- Asynchronous data enrichment pipelines
- Using S3 as a data lake foundation
- S3 event notifications and filtering
- Cross-origin access and bucket policies
- Glue Catalog integration for metadata management
- Data transformation with serverless ETL workflows
- Securing data at rest and in transit
- Compliance for data residency and sovereignty
Module 7: Security, Identity & Access Control - Principle of least privilege in serverless design
- Managing IAM roles and policies for Lambda functions
- Resource-based policies vs. identity-based policies
- Inline policies versus managed policies
- Policy simulation and security validation tools
- Temporary credentials and STS best practices
- Using service-linked roles appropriately
- Securing function URLs and public endpoints
- JWT validation and OAuth2 integration
- Using Amazon Cognito for user management
- Integrating with enterprise identity providers (SAML, OpenID Connect)
- Zero-trust architecture principles applied to serverless
- Network security: VPC, security groups, NACLs
- PrivateLink and interface endpoints for secure access
- Function isolation using VPC attachments
- Logging and monitoring for unauthorised access attempts
- Handling secrets securely in runtime environments
- Audit logging with CloudTrail and Data Events
- Static code analysis for security vulnerabilities
- Runtime protection with AWS GuardDuty and Lambda insights
Module 8: Observability & Real-Time Monitoring - Logs, metrics, and traces: the three pillars of observability
- CloudWatch Logs: log groups, streams, and subscriptions
- Structured logging with JSON formats
- Log filtering and search patterns
- CloudWatch Metrics and custom metric creation
- Alarm configuration for high error rates and latency
- Using CloudWatch Dashboards for real-time visibility
- Distributed tracing with AWS X-Ray
- X-Ray service maps and fault isolation
- Sampling strategies and overhead management
- Correlating traces across services and accounts
- Context propagation using trace headers
- Using OpenTelemetry for vendor-agnostic telemetry
- Exporting metrics to Datadog, New Relic, or Prometheus
- Centralised logging across multiple regions and accounts
- Kinesis Data Firehose for log aggregation
- Alerting workflows with SNS and incident management
- Mean time to detection and resolution benchmarks
- Health checks and synthetic monitoring
- Capacity planning based on execution trends
Module 9: Performance Optimisation & Cost Efficiency - Understanding pricing models: duration, memory, invocations
- Calculating total cost of ownership for serverless systems
- Memory allocation optimisation
- Duration profiling and bottleneck identification
- Provisioned concurrency: cost vs. performance trade-offs
- Managing cold starts with keep-warm strategies
- Function initialisation vs. handling phases
- Dependency bundling and layer optimisation
- Minifying and tree-shaking Node.js packages
- Using lightweight base images for custom runtimes
- Batching requests to reduce invocation counts
- Throttling and retry logic for downstream services
- Auto-scaling concurrency limits and quotas
- Cost allocation and chargeback reporting
- Usage forecasting with AWS Cost Explorer
- Reserved concurrency: when and how to use it
- Monitoring for cost anomalies and alerting
- Cost-aware architecture reviews and approvals
- Right-sizing functions based on historical patterns
- Eliminating idle compute and wasted spend
Module 10: Advanced Serverless Patterns & Anti-Patterns - Sidecar pattern for co-located utilities
- Choreography versus orchestration in workflows
- Message-driven choreography with event buses
- Process managers and saga patterns for distributed transactions
- Compensating actions for rollback logic
- Monorepo vs. polyrepo for function management
- Shared libraries and layer versioning
- Circular dependency identification and refactoring
- Function chaining and its risks
- Fan-out and gather for parallel processing
- Backpressure handling in high-throughput systems
- Rate limiting and quota enforcement at API level
- API versioning and deprecation strategies
- Hybrid architectures: integrating serverless with containers
- Serverless web applications with S3 and CloudFront
- Static site generation with serverless build pipelines
- Real-time applications with WebSockets and API Gateway
- Streaming data processing with Kinesis and Lambda
- Using Lambda for image and file transformations
- Automated document processing workflows
Module 11: Integration with Enterprise Systems - Connecting serverless to legacy backend systems
- Using API proxies for mainframe integration
- Message queue integration with IBM MQ and ActiveMQ
- Event sourcing from relational databases
- Change Data Capture (CDC) with Debezium and Lambda
- Batch-to-real-time transformation strategies
- Integrating with ERP and CRM platforms
- Using serverless for Salesforce and SAP integrations
- Middleware abstraction layers for vendor neutrality
- Business process automation with serverless orchestrators
- Secure hybrid connectivity using Direct Connect and VPN
- On-premises function execution via AWS Outposts
- Edge computing with Lambda@Edge
- Content personalisation at the CDN layer
- Authentication and authorisation across domains
- Data transformation in transit
- Enterprise service bus (ESB) modernisation
- Replacing batch jobs with event-driven triggers
- Master data management in serverless contexts
- Real-time reporting and analytics pipelines
Module 12: Building Serverless APIs & Microservices - REST API design principles for serverless backends
- API Gateway: routes, methods, integrations
- Request validation and schema enforcement
- Custom authorisers and JWT validation
- Usage plans, API keys, and rate limiting
- Stages, deployments, and base path mappings
- Custom domain names and TLS configuration
- GraphQL with AWS AppSync and serverless resolvers
- Resolver mapping templates and VTL
- Data sources: DynamoDB, HTTP, Lambda, RDS
- Real-time subscriptions using WebSockets
- API versioning and backward compatibility
- Documentation generation with OpenAPI specs
- Automated API testing with Postman and Newman
- Canary deployments for API updates
- Throttling and burst protection
- Caching strategies with CloudFront and API Gateway
- Monitoring API health and error rates
- Authentication gateways with Cognito User Pools
- Multi-tenant API patterns with context routing
Module 13: Serverless for Data Engineering & Analytics - Serverless ETL pipelines with Step Functions
- Partitioning strategies for S3 data lakes
- Using Glue for schema inference and ETL jobs
- Athena for serverless SQL querying
- Optimising query performance with partitioning and compression
- Parquet and ORC format advantages
- Automated data validation and quality checks
- Streaming ingestion with Kinesis and Lambda
- Real-time dashboards with QuickSight and Lambda
- Scheduling batch jobs with EventBridge and Cron
- Data lineage tracking with AWS Lake Formation
- Tagging and classification for governance
- Secure access to data for analytics teams
- Cost allocation by department or project
- Alerting on data pipeline failures
- Automated recovery and notification workflows
- Building data APIs for downstream consumers
- Using Lambda to serve model predictions
- Streaming analytics with Kinesis Data Analytics
- Alerting on anomalies in real-time data streams
Module 14: DevOps & SRE Practices for Serverless - Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
- Serverless maturity model for large organisations
- Establishing governance policies for function deployment
- Function ownership and lifecycle management
- Policy as code for security and compliance
- Multi-account and multi-region deployment strategies
- Role-based access control (RBAC) in serverless contexts
- Compliance frameworks: GDPR, HIPAA, SOC 2 alignment
- Audit trail configuration and log retention policies
- Centralised monitoring and alerting standards
- Cost allocation tagging and chargeback mechanisms
- Change management workflows for serverless components
- Disaster recovery planning for serverless systems
- Backup strategies for stateful dependencies
- Enterprise-ready naming conventions and metadata use
- Policy enforcement using AWS Config, Azure Policy, or GCP Org Policies
- Security posture assessment at scale
- Standardising deployment pipelines across teams
Module 3: Core Serverless Platforms & Provider Deep Dives - AWS Lambda: architecture, limits, and best practices
- Azure Functions: consumption plan vs. premium plan use cases
- Google Cloud Functions and Cloud Run comparisons
- IBM Cloud Functions and Apache OpenWhisk fundamentals
- Alibaba Function Compute for Asia-Pacific deployments
- Oracle Functions and integration with Oracle Cloud Infrastructure
- Comparing cold start performance across providers
- Memory, timeout, and concurrency configurations
- Networking capabilities: VPC, ENI, and egress control
- Runtime support: Node.js, Python, Java, Go, .NET, Rust
- Container-based function packaging: opting into custom runtimes
- Branded managed services: API Gateway, EventBridge, SNS, SQS
- Event sources and polling versus push-based models
- Limits and quotas: understanding and requesting increases
- Regional availability and failover capabilities
- Service-level agreements and uptime guarantees
- Choosing a provider based on enterprise requirements
- Multicloud serverless: feasibility and complexity trade-offs
Module 4: Event-Driven Design & Message Orchestration - Principles of event sourcing and CQRS
- Designing event schemas with schema registries
- Message brokers: Amazon SNS, SQS, EventBridge, Pub/Sub
- Event routing patterns: fan-out, filtering, content-based
- Idempotency and deduplication strategies
- Dead letter queues and error handling workflows
- Message ordering guarantees and limitations
- Event consistency across distributed services
- Event-driven workflows with Step Functions and Logic Apps
- State machines for complex serverless orchestrations
- Human-in-the-loop approvals in automated flows
- Error escalation and retry policies
- Event schema evolution and backward compatibility
- Event mesh architecture for enterprise integration
- Using message headers for tracing and context propagation
- Event storming techniques for domain modelling
- Coupling levels in event-driven systems
- Testing event-driven interactions and integration points
Module 5: Infrastructure as Code & Deployment Automation - Introduction to IaC for serverless systems
- AWS CloudFormation: templates, parameters, and conditions
- Using AWS SAM for simplified serverless deployments
- Serverless Framework: components, plugins, and stages
- Terraform for multicloud serverless provisioning
- Pulumi with TypeScript and Python for modern IaC
- Defining functions, triggers, and permissions as code
- Parameterisation of environment-specific configurations
- Custom resources and provider extensions
- Managing shared layers and dependencies
- Versioning strategies for functions and APIs
- Blue-green deployments for serverless APIs
- Canary releases using API Gateway and weighted routing
- Rollback automation and recovery playbooks
- CI/CD pipelines with GitHub Actions, GitLab CI, Jenkins
- Automated testing in deployment workflows
- Security scanning in pre-deployment gates
- Secrets management: AWS Secrets Manager, HashiCorp Vault
- Environment isolation using stages and accounts
- Drift detection and configuration reconciliation
Module 6: Data Management in Serverless Environments - Choosing databases for serverless: relational vs. NoSQL
- Amazon DynamoDB: throughput modes, GSIs, LSIs
- DynamoDB streams for change data capture
- Time-to-live (TTL) configuration for data lifecycle
- Amazon Aurora Serverless: when to consider it
- Data access patterns and query optimisation
- Connection pooling with RDS Proxy
- Google Cloud Firestore and Firestore in Datastore mode
- Azure Cosmos DB serverless tier
- Eventual consistency challenges and mitigation
- Data validation at ingestion points
- Batch processing with Step Functions and batch windows
- Asynchronous data enrichment pipelines
- Using S3 as a data lake foundation
- S3 event notifications and filtering
- Cross-origin access and bucket policies
- Glue Catalog integration for metadata management
- Data transformation with serverless ETL workflows
- Securing data at rest and in transit
- Compliance for data residency and sovereignty
Module 7: Security, Identity & Access Control - Principle of least privilege in serverless design
- Managing IAM roles and policies for Lambda functions
- Resource-based policies vs. identity-based policies
- Inline policies versus managed policies
- Policy simulation and security validation tools
- Temporary credentials and STS best practices
- Using service-linked roles appropriately
- Securing function URLs and public endpoints
- JWT validation and OAuth2 integration
- Using Amazon Cognito for user management
- Integrating with enterprise identity providers (SAML, OpenID Connect)
- Zero-trust architecture principles applied to serverless
- Network security: VPC, security groups, NACLs
- PrivateLink and interface endpoints for secure access
- Function isolation using VPC attachments
- Logging and monitoring for unauthorised access attempts
- Handling secrets securely in runtime environments
- Audit logging with CloudTrail and Data Events
- Static code analysis for security vulnerabilities
- Runtime protection with AWS GuardDuty and Lambda insights
Module 8: Observability & Real-Time Monitoring - Logs, metrics, and traces: the three pillars of observability
- CloudWatch Logs: log groups, streams, and subscriptions
- Structured logging with JSON formats
- Log filtering and search patterns
- CloudWatch Metrics and custom metric creation
- Alarm configuration for high error rates and latency
- Using CloudWatch Dashboards for real-time visibility
- Distributed tracing with AWS X-Ray
- X-Ray service maps and fault isolation
- Sampling strategies and overhead management
- Correlating traces across services and accounts
- Context propagation using trace headers
- Using OpenTelemetry for vendor-agnostic telemetry
- Exporting metrics to Datadog, New Relic, or Prometheus
- Centralised logging across multiple regions and accounts
- Kinesis Data Firehose for log aggregation
- Alerting workflows with SNS and incident management
- Mean time to detection and resolution benchmarks
- Health checks and synthetic monitoring
- Capacity planning based on execution trends
Module 9: Performance Optimisation & Cost Efficiency - Understanding pricing models: duration, memory, invocations
- Calculating total cost of ownership for serverless systems
- Memory allocation optimisation
- Duration profiling and bottleneck identification
- Provisioned concurrency: cost vs. performance trade-offs
- Managing cold starts with keep-warm strategies
- Function initialisation vs. handling phases
- Dependency bundling and layer optimisation
- Minifying and tree-shaking Node.js packages
- Using lightweight base images for custom runtimes
- Batching requests to reduce invocation counts
- Throttling and retry logic for downstream services
- Auto-scaling concurrency limits and quotas
- Cost allocation and chargeback reporting
- Usage forecasting with AWS Cost Explorer
- Reserved concurrency: when and how to use it
- Monitoring for cost anomalies and alerting
- Cost-aware architecture reviews and approvals
- Right-sizing functions based on historical patterns
- Eliminating idle compute and wasted spend
Module 10: Advanced Serverless Patterns & Anti-Patterns - Sidecar pattern for co-located utilities
- Choreography versus orchestration in workflows
- Message-driven choreography with event buses
- Process managers and saga patterns for distributed transactions
- Compensating actions for rollback logic
- Monorepo vs. polyrepo for function management
- Shared libraries and layer versioning
- Circular dependency identification and refactoring
- Function chaining and its risks
- Fan-out and gather for parallel processing
- Backpressure handling in high-throughput systems
- Rate limiting and quota enforcement at API level
- API versioning and deprecation strategies
- Hybrid architectures: integrating serverless with containers
- Serverless web applications with S3 and CloudFront
- Static site generation with serverless build pipelines
- Real-time applications with WebSockets and API Gateway
- Streaming data processing with Kinesis and Lambda
- Using Lambda for image and file transformations
- Automated document processing workflows
Module 11: Integration with Enterprise Systems - Connecting serverless to legacy backend systems
- Using API proxies for mainframe integration
- Message queue integration with IBM MQ and ActiveMQ
- Event sourcing from relational databases
- Change Data Capture (CDC) with Debezium and Lambda
- Batch-to-real-time transformation strategies
- Integrating with ERP and CRM platforms
- Using serverless for Salesforce and SAP integrations
- Middleware abstraction layers for vendor neutrality
- Business process automation with serverless orchestrators
- Secure hybrid connectivity using Direct Connect and VPN
- On-premises function execution via AWS Outposts
- Edge computing with Lambda@Edge
- Content personalisation at the CDN layer
- Authentication and authorisation across domains
- Data transformation in transit
- Enterprise service bus (ESB) modernisation
- Replacing batch jobs with event-driven triggers
- Master data management in serverless contexts
- Real-time reporting and analytics pipelines
Module 12: Building Serverless APIs & Microservices - REST API design principles for serverless backends
- API Gateway: routes, methods, integrations
- Request validation and schema enforcement
- Custom authorisers and JWT validation
- Usage plans, API keys, and rate limiting
- Stages, deployments, and base path mappings
- Custom domain names and TLS configuration
- GraphQL with AWS AppSync and serverless resolvers
- Resolver mapping templates and VTL
- Data sources: DynamoDB, HTTP, Lambda, RDS
- Real-time subscriptions using WebSockets
- API versioning and backward compatibility
- Documentation generation with OpenAPI specs
- Automated API testing with Postman and Newman
- Canary deployments for API updates
- Throttling and burst protection
- Caching strategies with CloudFront and API Gateway
- Monitoring API health and error rates
- Authentication gateways with Cognito User Pools
- Multi-tenant API patterns with context routing
Module 13: Serverless for Data Engineering & Analytics - Serverless ETL pipelines with Step Functions
- Partitioning strategies for S3 data lakes
- Using Glue for schema inference and ETL jobs
- Athena for serverless SQL querying
- Optimising query performance with partitioning and compression
- Parquet and ORC format advantages
- Automated data validation and quality checks
- Streaming ingestion with Kinesis and Lambda
- Real-time dashboards with QuickSight and Lambda
- Scheduling batch jobs with EventBridge and Cron
- Data lineage tracking with AWS Lake Formation
- Tagging and classification for governance
- Secure access to data for analytics teams
- Cost allocation by department or project
- Alerting on data pipeline failures
- Automated recovery and notification workflows
- Building data APIs for downstream consumers
- Using Lambda to serve model predictions
- Streaming analytics with Kinesis Data Analytics
- Alerting on anomalies in real-time data streams
Module 14: DevOps & SRE Practices for Serverless - Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
- Principles of event sourcing and CQRS
- Designing event schemas with schema registries
- Message brokers: Amazon SNS, SQS, EventBridge, Pub/Sub
- Event routing patterns: fan-out, filtering, content-based
- Idempotency and deduplication strategies
- Dead letter queues and error handling workflows
- Message ordering guarantees and limitations
- Event consistency across distributed services
- Event-driven workflows with Step Functions and Logic Apps
- State machines for complex serverless orchestrations
- Human-in-the-loop approvals in automated flows
- Error escalation and retry policies
- Event schema evolution and backward compatibility
- Event mesh architecture for enterprise integration
- Using message headers for tracing and context propagation
- Event storming techniques for domain modelling
- Coupling levels in event-driven systems
- Testing event-driven interactions and integration points
Module 5: Infrastructure as Code & Deployment Automation - Introduction to IaC for serverless systems
- AWS CloudFormation: templates, parameters, and conditions
- Using AWS SAM for simplified serverless deployments
- Serverless Framework: components, plugins, and stages
- Terraform for multicloud serverless provisioning
- Pulumi with TypeScript and Python for modern IaC
- Defining functions, triggers, and permissions as code
- Parameterisation of environment-specific configurations
- Custom resources and provider extensions
- Managing shared layers and dependencies
- Versioning strategies for functions and APIs
- Blue-green deployments for serverless APIs
- Canary releases using API Gateway and weighted routing
- Rollback automation and recovery playbooks
- CI/CD pipelines with GitHub Actions, GitLab CI, Jenkins
- Automated testing in deployment workflows
- Security scanning in pre-deployment gates
- Secrets management: AWS Secrets Manager, HashiCorp Vault
- Environment isolation using stages and accounts
- Drift detection and configuration reconciliation
Module 6: Data Management in Serverless Environments - Choosing databases for serverless: relational vs. NoSQL
- Amazon DynamoDB: throughput modes, GSIs, LSIs
- DynamoDB streams for change data capture
- Time-to-live (TTL) configuration for data lifecycle
- Amazon Aurora Serverless: when to consider it
- Data access patterns and query optimisation
- Connection pooling with RDS Proxy
- Google Cloud Firestore and Firestore in Datastore mode
- Azure Cosmos DB serverless tier
- Eventual consistency challenges and mitigation
- Data validation at ingestion points
- Batch processing with Step Functions and batch windows
- Asynchronous data enrichment pipelines
- Using S3 as a data lake foundation
- S3 event notifications and filtering
- Cross-origin access and bucket policies
- Glue Catalog integration for metadata management
- Data transformation with serverless ETL workflows
- Securing data at rest and in transit
- Compliance for data residency and sovereignty
Module 7: Security, Identity & Access Control - Principle of least privilege in serverless design
- Managing IAM roles and policies for Lambda functions
- Resource-based policies vs. identity-based policies
- Inline policies versus managed policies
- Policy simulation and security validation tools
- Temporary credentials and STS best practices
- Using service-linked roles appropriately
- Securing function URLs and public endpoints
- JWT validation and OAuth2 integration
- Using Amazon Cognito for user management
- Integrating with enterprise identity providers (SAML, OpenID Connect)
- Zero-trust architecture principles applied to serverless
- Network security: VPC, security groups, NACLs
- PrivateLink and interface endpoints for secure access
- Function isolation using VPC attachments
- Logging and monitoring for unauthorised access attempts
- Handling secrets securely in runtime environments
- Audit logging with CloudTrail and Data Events
- Static code analysis for security vulnerabilities
- Runtime protection with AWS GuardDuty and Lambda insights
Module 8: Observability & Real-Time Monitoring - Logs, metrics, and traces: the three pillars of observability
- CloudWatch Logs: log groups, streams, and subscriptions
- Structured logging with JSON formats
- Log filtering and search patterns
- CloudWatch Metrics and custom metric creation
- Alarm configuration for high error rates and latency
- Using CloudWatch Dashboards for real-time visibility
- Distributed tracing with AWS X-Ray
- X-Ray service maps and fault isolation
- Sampling strategies and overhead management
- Correlating traces across services and accounts
- Context propagation using trace headers
- Using OpenTelemetry for vendor-agnostic telemetry
- Exporting metrics to Datadog, New Relic, or Prometheus
- Centralised logging across multiple regions and accounts
- Kinesis Data Firehose for log aggregation
- Alerting workflows with SNS and incident management
- Mean time to detection and resolution benchmarks
- Health checks and synthetic monitoring
- Capacity planning based on execution trends
Module 9: Performance Optimisation & Cost Efficiency - Understanding pricing models: duration, memory, invocations
- Calculating total cost of ownership for serverless systems
- Memory allocation optimisation
- Duration profiling and bottleneck identification
- Provisioned concurrency: cost vs. performance trade-offs
- Managing cold starts with keep-warm strategies
- Function initialisation vs. handling phases
- Dependency bundling and layer optimisation
- Minifying and tree-shaking Node.js packages
- Using lightweight base images for custom runtimes
- Batching requests to reduce invocation counts
- Throttling and retry logic for downstream services
- Auto-scaling concurrency limits and quotas
- Cost allocation and chargeback reporting
- Usage forecasting with AWS Cost Explorer
- Reserved concurrency: when and how to use it
- Monitoring for cost anomalies and alerting
- Cost-aware architecture reviews and approvals
- Right-sizing functions based on historical patterns
- Eliminating idle compute and wasted spend
Module 10: Advanced Serverless Patterns & Anti-Patterns - Sidecar pattern for co-located utilities
- Choreography versus orchestration in workflows
- Message-driven choreography with event buses
- Process managers and saga patterns for distributed transactions
- Compensating actions for rollback logic
- Monorepo vs. polyrepo for function management
- Shared libraries and layer versioning
- Circular dependency identification and refactoring
- Function chaining and its risks
- Fan-out and gather for parallel processing
- Backpressure handling in high-throughput systems
- Rate limiting and quota enforcement at API level
- API versioning and deprecation strategies
- Hybrid architectures: integrating serverless with containers
- Serverless web applications with S3 and CloudFront
- Static site generation with serverless build pipelines
- Real-time applications with WebSockets and API Gateway
- Streaming data processing with Kinesis and Lambda
- Using Lambda for image and file transformations
- Automated document processing workflows
Module 11: Integration with Enterprise Systems - Connecting serverless to legacy backend systems
- Using API proxies for mainframe integration
- Message queue integration with IBM MQ and ActiveMQ
- Event sourcing from relational databases
- Change Data Capture (CDC) with Debezium and Lambda
- Batch-to-real-time transformation strategies
- Integrating with ERP and CRM platforms
- Using serverless for Salesforce and SAP integrations
- Middleware abstraction layers for vendor neutrality
- Business process automation with serverless orchestrators
- Secure hybrid connectivity using Direct Connect and VPN
- On-premises function execution via AWS Outposts
- Edge computing with Lambda@Edge
- Content personalisation at the CDN layer
- Authentication and authorisation across domains
- Data transformation in transit
- Enterprise service bus (ESB) modernisation
- Replacing batch jobs with event-driven triggers
- Master data management in serverless contexts
- Real-time reporting and analytics pipelines
Module 12: Building Serverless APIs & Microservices - REST API design principles for serverless backends
- API Gateway: routes, methods, integrations
- Request validation and schema enforcement
- Custom authorisers and JWT validation
- Usage plans, API keys, and rate limiting
- Stages, deployments, and base path mappings
- Custom domain names and TLS configuration
- GraphQL with AWS AppSync and serverless resolvers
- Resolver mapping templates and VTL
- Data sources: DynamoDB, HTTP, Lambda, RDS
- Real-time subscriptions using WebSockets
- API versioning and backward compatibility
- Documentation generation with OpenAPI specs
- Automated API testing with Postman and Newman
- Canary deployments for API updates
- Throttling and burst protection
- Caching strategies with CloudFront and API Gateway
- Monitoring API health and error rates
- Authentication gateways with Cognito User Pools
- Multi-tenant API patterns with context routing
Module 13: Serverless for Data Engineering & Analytics - Serverless ETL pipelines with Step Functions
- Partitioning strategies for S3 data lakes
- Using Glue for schema inference and ETL jobs
- Athena for serverless SQL querying
- Optimising query performance with partitioning and compression
- Parquet and ORC format advantages
- Automated data validation and quality checks
- Streaming ingestion with Kinesis and Lambda
- Real-time dashboards with QuickSight and Lambda
- Scheduling batch jobs with EventBridge and Cron
- Data lineage tracking with AWS Lake Formation
- Tagging and classification for governance
- Secure access to data for analytics teams
- Cost allocation by department or project
- Alerting on data pipeline failures
- Automated recovery and notification workflows
- Building data APIs for downstream consumers
- Using Lambda to serve model predictions
- Streaming analytics with Kinesis Data Analytics
- Alerting on anomalies in real-time data streams
Module 14: DevOps & SRE Practices for Serverless - Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
- Choosing databases for serverless: relational vs. NoSQL
- Amazon DynamoDB: throughput modes, GSIs, LSIs
- DynamoDB streams for change data capture
- Time-to-live (TTL) configuration for data lifecycle
- Amazon Aurora Serverless: when to consider it
- Data access patterns and query optimisation
- Connection pooling with RDS Proxy
- Google Cloud Firestore and Firestore in Datastore mode
- Azure Cosmos DB serverless tier
- Eventual consistency challenges and mitigation
- Data validation at ingestion points
- Batch processing with Step Functions and batch windows
- Asynchronous data enrichment pipelines
- Using S3 as a data lake foundation
- S3 event notifications and filtering
- Cross-origin access and bucket policies
- Glue Catalog integration for metadata management
- Data transformation with serverless ETL workflows
- Securing data at rest and in transit
- Compliance for data residency and sovereignty
Module 7: Security, Identity & Access Control - Principle of least privilege in serverless design
- Managing IAM roles and policies for Lambda functions
- Resource-based policies vs. identity-based policies
- Inline policies versus managed policies
- Policy simulation and security validation tools
- Temporary credentials and STS best practices
- Using service-linked roles appropriately
- Securing function URLs and public endpoints
- JWT validation and OAuth2 integration
- Using Amazon Cognito for user management
- Integrating with enterprise identity providers (SAML, OpenID Connect)
- Zero-trust architecture principles applied to serverless
- Network security: VPC, security groups, NACLs
- PrivateLink and interface endpoints for secure access
- Function isolation using VPC attachments
- Logging and monitoring for unauthorised access attempts
- Handling secrets securely in runtime environments
- Audit logging with CloudTrail and Data Events
- Static code analysis for security vulnerabilities
- Runtime protection with AWS GuardDuty and Lambda insights
Module 8: Observability & Real-Time Monitoring - Logs, metrics, and traces: the three pillars of observability
- CloudWatch Logs: log groups, streams, and subscriptions
- Structured logging with JSON formats
- Log filtering and search patterns
- CloudWatch Metrics and custom metric creation
- Alarm configuration for high error rates and latency
- Using CloudWatch Dashboards for real-time visibility
- Distributed tracing with AWS X-Ray
- X-Ray service maps and fault isolation
- Sampling strategies and overhead management
- Correlating traces across services and accounts
- Context propagation using trace headers
- Using OpenTelemetry for vendor-agnostic telemetry
- Exporting metrics to Datadog, New Relic, or Prometheus
- Centralised logging across multiple regions and accounts
- Kinesis Data Firehose for log aggregation
- Alerting workflows with SNS and incident management
- Mean time to detection and resolution benchmarks
- Health checks and synthetic monitoring
- Capacity planning based on execution trends
Module 9: Performance Optimisation & Cost Efficiency - Understanding pricing models: duration, memory, invocations
- Calculating total cost of ownership for serverless systems
- Memory allocation optimisation
- Duration profiling and bottleneck identification
- Provisioned concurrency: cost vs. performance trade-offs
- Managing cold starts with keep-warm strategies
- Function initialisation vs. handling phases
- Dependency bundling and layer optimisation
- Minifying and tree-shaking Node.js packages
- Using lightweight base images for custom runtimes
- Batching requests to reduce invocation counts
- Throttling and retry logic for downstream services
- Auto-scaling concurrency limits and quotas
- Cost allocation and chargeback reporting
- Usage forecasting with AWS Cost Explorer
- Reserved concurrency: when and how to use it
- Monitoring for cost anomalies and alerting
- Cost-aware architecture reviews and approvals
- Right-sizing functions based on historical patterns
- Eliminating idle compute and wasted spend
Module 10: Advanced Serverless Patterns & Anti-Patterns - Sidecar pattern for co-located utilities
- Choreography versus orchestration in workflows
- Message-driven choreography with event buses
- Process managers and saga patterns for distributed transactions
- Compensating actions for rollback logic
- Monorepo vs. polyrepo for function management
- Shared libraries and layer versioning
- Circular dependency identification and refactoring
- Function chaining and its risks
- Fan-out and gather for parallel processing
- Backpressure handling in high-throughput systems
- Rate limiting and quota enforcement at API level
- API versioning and deprecation strategies
- Hybrid architectures: integrating serverless with containers
- Serverless web applications with S3 and CloudFront
- Static site generation with serverless build pipelines
- Real-time applications with WebSockets and API Gateway
- Streaming data processing with Kinesis and Lambda
- Using Lambda for image and file transformations
- Automated document processing workflows
Module 11: Integration with Enterprise Systems - Connecting serverless to legacy backend systems
- Using API proxies for mainframe integration
- Message queue integration with IBM MQ and ActiveMQ
- Event sourcing from relational databases
- Change Data Capture (CDC) with Debezium and Lambda
- Batch-to-real-time transformation strategies
- Integrating with ERP and CRM platforms
- Using serverless for Salesforce and SAP integrations
- Middleware abstraction layers for vendor neutrality
- Business process automation with serverless orchestrators
- Secure hybrid connectivity using Direct Connect and VPN
- On-premises function execution via AWS Outposts
- Edge computing with Lambda@Edge
- Content personalisation at the CDN layer
- Authentication and authorisation across domains
- Data transformation in transit
- Enterprise service bus (ESB) modernisation
- Replacing batch jobs with event-driven triggers
- Master data management in serverless contexts
- Real-time reporting and analytics pipelines
Module 12: Building Serverless APIs & Microservices - REST API design principles for serverless backends
- API Gateway: routes, methods, integrations
- Request validation and schema enforcement
- Custom authorisers and JWT validation
- Usage plans, API keys, and rate limiting
- Stages, deployments, and base path mappings
- Custom domain names and TLS configuration
- GraphQL with AWS AppSync and serverless resolvers
- Resolver mapping templates and VTL
- Data sources: DynamoDB, HTTP, Lambda, RDS
- Real-time subscriptions using WebSockets
- API versioning and backward compatibility
- Documentation generation with OpenAPI specs
- Automated API testing with Postman and Newman
- Canary deployments for API updates
- Throttling and burst protection
- Caching strategies with CloudFront and API Gateway
- Monitoring API health and error rates
- Authentication gateways with Cognito User Pools
- Multi-tenant API patterns with context routing
Module 13: Serverless for Data Engineering & Analytics - Serverless ETL pipelines with Step Functions
- Partitioning strategies for S3 data lakes
- Using Glue for schema inference and ETL jobs
- Athena for serverless SQL querying
- Optimising query performance with partitioning and compression
- Parquet and ORC format advantages
- Automated data validation and quality checks
- Streaming ingestion with Kinesis and Lambda
- Real-time dashboards with QuickSight and Lambda
- Scheduling batch jobs with EventBridge and Cron
- Data lineage tracking with AWS Lake Formation
- Tagging and classification for governance
- Secure access to data for analytics teams
- Cost allocation by department or project
- Alerting on data pipeline failures
- Automated recovery and notification workflows
- Building data APIs for downstream consumers
- Using Lambda to serve model predictions
- Streaming analytics with Kinesis Data Analytics
- Alerting on anomalies in real-time data streams
Module 14: DevOps & SRE Practices for Serverless - Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
- Logs, metrics, and traces: the three pillars of observability
- CloudWatch Logs: log groups, streams, and subscriptions
- Structured logging with JSON formats
- Log filtering and search patterns
- CloudWatch Metrics and custom metric creation
- Alarm configuration for high error rates and latency
- Using CloudWatch Dashboards for real-time visibility
- Distributed tracing with AWS X-Ray
- X-Ray service maps and fault isolation
- Sampling strategies and overhead management
- Correlating traces across services and accounts
- Context propagation using trace headers
- Using OpenTelemetry for vendor-agnostic telemetry
- Exporting metrics to Datadog, New Relic, or Prometheus
- Centralised logging across multiple regions and accounts
- Kinesis Data Firehose for log aggregation
- Alerting workflows with SNS and incident management
- Mean time to detection and resolution benchmarks
- Health checks and synthetic monitoring
- Capacity planning based on execution trends
Module 9: Performance Optimisation & Cost Efficiency - Understanding pricing models: duration, memory, invocations
- Calculating total cost of ownership for serverless systems
- Memory allocation optimisation
- Duration profiling and bottleneck identification
- Provisioned concurrency: cost vs. performance trade-offs
- Managing cold starts with keep-warm strategies
- Function initialisation vs. handling phases
- Dependency bundling and layer optimisation
- Minifying and tree-shaking Node.js packages
- Using lightweight base images for custom runtimes
- Batching requests to reduce invocation counts
- Throttling and retry logic for downstream services
- Auto-scaling concurrency limits and quotas
- Cost allocation and chargeback reporting
- Usage forecasting with AWS Cost Explorer
- Reserved concurrency: when and how to use it
- Monitoring for cost anomalies and alerting
- Cost-aware architecture reviews and approvals
- Right-sizing functions based on historical patterns
- Eliminating idle compute and wasted spend
Module 10: Advanced Serverless Patterns & Anti-Patterns - Sidecar pattern for co-located utilities
- Choreography versus orchestration in workflows
- Message-driven choreography with event buses
- Process managers and saga patterns for distributed transactions
- Compensating actions for rollback logic
- Monorepo vs. polyrepo for function management
- Shared libraries and layer versioning
- Circular dependency identification and refactoring
- Function chaining and its risks
- Fan-out and gather for parallel processing
- Backpressure handling in high-throughput systems
- Rate limiting and quota enforcement at API level
- API versioning and deprecation strategies
- Hybrid architectures: integrating serverless with containers
- Serverless web applications with S3 and CloudFront
- Static site generation with serverless build pipelines
- Real-time applications with WebSockets and API Gateway
- Streaming data processing with Kinesis and Lambda
- Using Lambda for image and file transformations
- Automated document processing workflows
Module 11: Integration with Enterprise Systems - Connecting serverless to legacy backend systems
- Using API proxies for mainframe integration
- Message queue integration with IBM MQ and ActiveMQ
- Event sourcing from relational databases
- Change Data Capture (CDC) with Debezium and Lambda
- Batch-to-real-time transformation strategies
- Integrating with ERP and CRM platforms
- Using serverless for Salesforce and SAP integrations
- Middleware abstraction layers for vendor neutrality
- Business process automation with serverless orchestrators
- Secure hybrid connectivity using Direct Connect and VPN
- On-premises function execution via AWS Outposts
- Edge computing with Lambda@Edge
- Content personalisation at the CDN layer
- Authentication and authorisation across domains
- Data transformation in transit
- Enterprise service bus (ESB) modernisation
- Replacing batch jobs with event-driven triggers
- Master data management in serverless contexts
- Real-time reporting and analytics pipelines
Module 12: Building Serverless APIs & Microservices - REST API design principles for serverless backends
- API Gateway: routes, methods, integrations
- Request validation and schema enforcement
- Custom authorisers and JWT validation
- Usage plans, API keys, and rate limiting
- Stages, deployments, and base path mappings
- Custom domain names and TLS configuration
- GraphQL with AWS AppSync and serverless resolvers
- Resolver mapping templates and VTL
- Data sources: DynamoDB, HTTP, Lambda, RDS
- Real-time subscriptions using WebSockets
- API versioning and backward compatibility
- Documentation generation with OpenAPI specs
- Automated API testing with Postman and Newman
- Canary deployments for API updates
- Throttling and burst protection
- Caching strategies with CloudFront and API Gateway
- Monitoring API health and error rates
- Authentication gateways with Cognito User Pools
- Multi-tenant API patterns with context routing
Module 13: Serverless for Data Engineering & Analytics - Serverless ETL pipelines with Step Functions
- Partitioning strategies for S3 data lakes
- Using Glue for schema inference and ETL jobs
- Athena for serverless SQL querying
- Optimising query performance with partitioning and compression
- Parquet and ORC format advantages
- Automated data validation and quality checks
- Streaming ingestion with Kinesis and Lambda
- Real-time dashboards with QuickSight and Lambda
- Scheduling batch jobs with EventBridge and Cron
- Data lineage tracking with AWS Lake Formation
- Tagging and classification for governance
- Secure access to data for analytics teams
- Cost allocation by department or project
- Alerting on data pipeline failures
- Automated recovery and notification workflows
- Building data APIs for downstream consumers
- Using Lambda to serve model predictions
- Streaming analytics with Kinesis Data Analytics
- Alerting on anomalies in real-time data streams
Module 14: DevOps & SRE Practices for Serverless - Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
- Sidecar pattern for co-located utilities
- Choreography versus orchestration in workflows
- Message-driven choreography with event buses
- Process managers and saga patterns for distributed transactions
- Compensating actions for rollback logic
- Monorepo vs. polyrepo for function management
- Shared libraries and layer versioning
- Circular dependency identification and refactoring
- Function chaining and its risks
- Fan-out and gather for parallel processing
- Backpressure handling in high-throughput systems
- Rate limiting and quota enforcement at API level
- API versioning and deprecation strategies
- Hybrid architectures: integrating serverless with containers
- Serverless web applications with S3 and CloudFront
- Static site generation with serverless build pipelines
- Real-time applications with WebSockets and API Gateway
- Streaming data processing with Kinesis and Lambda
- Using Lambda for image and file transformations
- Automated document processing workflows
Module 11: Integration with Enterprise Systems - Connecting serverless to legacy backend systems
- Using API proxies for mainframe integration
- Message queue integration with IBM MQ and ActiveMQ
- Event sourcing from relational databases
- Change Data Capture (CDC) with Debezium and Lambda
- Batch-to-real-time transformation strategies
- Integrating with ERP and CRM platforms
- Using serverless for Salesforce and SAP integrations
- Middleware abstraction layers for vendor neutrality
- Business process automation with serverless orchestrators
- Secure hybrid connectivity using Direct Connect and VPN
- On-premises function execution via AWS Outposts
- Edge computing with Lambda@Edge
- Content personalisation at the CDN layer
- Authentication and authorisation across domains
- Data transformation in transit
- Enterprise service bus (ESB) modernisation
- Replacing batch jobs with event-driven triggers
- Master data management in serverless contexts
- Real-time reporting and analytics pipelines
Module 12: Building Serverless APIs & Microservices - REST API design principles for serverless backends
- API Gateway: routes, methods, integrations
- Request validation and schema enforcement
- Custom authorisers and JWT validation
- Usage plans, API keys, and rate limiting
- Stages, deployments, and base path mappings
- Custom domain names and TLS configuration
- GraphQL with AWS AppSync and serverless resolvers
- Resolver mapping templates and VTL
- Data sources: DynamoDB, HTTP, Lambda, RDS
- Real-time subscriptions using WebSockets
- API versioning and backward compatibility
- Documentation generation with OpenAPI specs
- Automated API testing with Postman and Newman
- Canary deployments for API updates
- Throttling and burst protection
- Caching strategies with CloudFront and API Gateway
- Monitoring API health and error rates
- Authentication gateways with Cognito User Pools
- Multi-tenant API patterns with context routing
Module 13: Serverless for Data Engineering & Analytics - Serverless ETL pipelines with Step Functions
- Partitioning strategies for S3 data lakes
- Using Glue for schema inference and ETL jobs
- Athena for serverless SQL querying
- Optimising query performance with partitioning and compression
- Parquet and ORC format advantages
- Automated data validation and quality checks
- Streaming ingestion with Kinesis and Lambda
- Real-time dashboards with QuickSight and Lambda
- Scheduling batch jobs with EventBridge and Cron
- Data lineage tracking with AWS Lake Formation
- Tagging and classification for governance
- Secure access to data for analytics teams
- Cost allocation by department or project
- Alerting on data pipeline failures
- Automated recovery and notification workflows
- Building data APIs for downstream consumers
- Using Lambda to serve model predictions
- Streaming analytics with Kinesis Data Analytics
- Alerting on anomalies in real-time data streams
Module 14: DevOps & SRE Practices for Serverless - Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
- REST API design principles for serverless backends
- API Gateway: routes, methods, integrations
- Request validation and schema enforcement
- Custom authorisers and JWT validation
- Usage plans, API keys, and rate limiting
- Stages, deployments, and base path mappings
- Custom domain names and TLS configuration
- GraphQL with AWS AppSync and serverless resolvers
- Resolver mapping templates and VTL
- Data sources: DynamoDB, HTTP, Lambda, RDS
- Real-time subscriptions using WebSockets
- API versioning and backward compatibility
- Documentation generation with OpenAPI specs
- Automated API testing with Postman and Newman
- Canary deployments for API updates
- Throttling and burst protection
- Caching strategies with CloudFront and API Gateway
- Monitoring API health and error rates
- Authentication gateways with Cognito User Pools
- Multi-tenant API patterns with context routing
Module 13: Serverless for Data Engineering & Analytics - Serverless ETL pipelines with Step Functions
- Partitioning strategies for S3 data lakes
- Using Glue for schema inference and ETL jobs
- Athena for serverless SQL querying
- Optimising query performance with partitioning and compression
- Parquet and ORC format advantages
- Automated data validation and quality checks
- Streaming ingestion with Kinesis and Lambda
- Real-time dashboards with QuickSight and Lambda
- Scheduling batch jobs with EventBridge and Cron
- Data lineage tracking with AWS Lake Formation
- Tagging and classification for governance
- Secure access to data for analytics teams
- Cost allocation by department or project
- Alerting on data pipeline failures
- Automated recovery and notification workflows
- Building data APIs for downstream consumers
- Using Lambda to serve model predictions
- Streaming analytics with Kinesis Data Analytics
- Alerting on anomalies in real-time data streams
Module 14: DevOps & SRE Practices for Serverless - Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
- Incident response playbooks for serverless outages
- Blameless postmortems and root cause analysis
- Service Level Objectives (SLOs) for serverless APIs
- Error budgets and burn rate monitoring
- On-call rotations for serverless teams
- Automated self-healing workflows
- Health checks and synthetic transactions
- Chaos engineering for serverless resilience
- Simulating function failures and timeouts
- Dependency failure testing
- Feature flagging with LaunchDarkly and AppConfig
- Blue-green testing in staging environments
- Progressive delivery strategies
- Automated rollback triggers based on metrics
- Runbook automation with Systems Manager
- Monitoring platform health across teams
- Shared tooling and developer enablement
- Developer self-service portals for deployment
- Internal documentation and knowledge sharing
- Metric dashboards for team performance tracking
Module 15: Migration Strategies & Legacy Modernisation - Assessment frameworks for monolith to serverless
- Strangler Fig pattern implementation
- Identifying candidate services for extraction
- Data migration techniques for legacy databases
- API façade creation with API Gateway
- Traffic shifting strategies: shadowing, canary, full cutover
- Testing in parallel systems
- Dependency analysis and service decomposition
- Refactoring stateful logic into stateless functions
- Session management in serverless web apps
- Caching strategies with ElastiCache and DAX
- Handling long-running processes with Step Functions
- Asynchronous workflow conversion
- Batch processing modernisation
- Security policy alignment during migration
- Cost comparison before and after migration
- Performance benchmarking and SLA validation
- Team training and capability uplift plans
- Change communication strategies
- Post-migration optimisation review
Module 16: Certification Preparation & Next Steps - Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service
- Review of all core serverless concepts
- Exam-style assessment with detailed feedback
- Real-world scenario analysis and decision exercises
- Architecture trade-off discussions
- Troubleshooting common serverless issues
- Optimising for cost, performance, and security
- Presenting serverless designs to stakeholders
- Building a professional portfolio of projects
- Creating a personal serverless GitHub repository
- Documenting case studies and deployment successes
- Contributing to open-source serverless tools
- Joining serverless communities and forums
- Speaking at meetups and conferences
- Preparing for advanced cloud certifications
- Negotiating roles with serverless expertise
- Demonstrating ROI to management
- Leading serverless adoption in your organisation
- Final project: design and document an enterprise serverless system
- Submission for review and feedback
- Receiving your Certificate of Completion issued by The Art of Service