CF

Production-Ready Serverless

13h 37m 6s
English
Paid

Unlock Your Serverless Potential with the Production-Ready Serverless Course

The Production-Ready Serverless course is your gateway to mastering the art of creating resilient and scalable serverless applications that are ready for production deployment. This course covers essential topics such as reliable deployment, security assurance, performance monitoring, and cost control. You will learn best practices for developing and optimizing applications in cloud environments, gaining practical insights and examples using modern tools to build efficient infrastructure.

Course Benefits

Gain Confidence in Your Skills and Become an Expert in Serverless Technologies

This course offers comprehensive training on Serverless architectures using AWS, covering all crucial aspects of developing, deploying, and optimizing serverless applications. It's designed for those who aspire to become indispensable experts in their field.

Why Choose This Course

  • Enhance Job Security and Demand:
    • Master Serverless quickly and establish yourself as a leading specialist in your company.
  • Clear Learning Structure:
    • Engage in a step-by-step program that covers key topics and deepens your understanding of the technologies.
  • Relevance:
    • Stay updated with the latest trends and AWS updates as the course content regularly evolves.
  • Learn from a Global Expert:
    • Gain insights from an instructor with recognized authority in Serverless development.

Target Audience

Who This Course is For:

  • Backend Engineers
  • Cloud Engineers
  • DevOps Engineers
  • Technical Leaders
  • Fullstack Developers
  • Architects
  • Security Engineers
  • Testing and QA Engineers

Prerequisites

Who This Course is Not For:

If you lack an IT background, it is recommended to complete basic courses before enrolling in this training. A foundational understanding of programming is also required.

Course Structure

Step-by-Step Learning Program:

Week 1: Introduction and REST API

  • Basics of AWS and Serverless
  • Lambda: Deep Dive
  • Infrastructure as Code (IaC)
  • Building REST API with API Gateway and Lambda

Week 2: Testing and CI/CD

  • Testing Serverless Architectures
  • CI/CD with GitHub Actions
  • Ephemeral Environments
  • Configuration and Secrets Management

Week 3: Event-Driven Architectures and DDD

  • Introduction to Event-Driven Architectures
  • Testing Event-Driven Applications
  • Domain-Driven Design (DDD)
  • Error Handling and Idempotency

Week 4: Observability, Cost, and Performance

  • Lambda Logging Practices
  • Distributed Tracing with AWS X-Ray
  • Monitoring and Notifications
  • Performance and Cost Optimization

Learning Outcomes

  • Confidence in working with Serverless applications
  • Ability to make informed architectural decisions
  • Mastery of advanced testing and debugging methods
  • Enhanced capability to optimize application performance in production environments

Course Schedule

Recommended Schedule: Dedicate 10-15 hours per week to your studies. Although designed for 4 weeks, the course offers the flexibility to progress at your own pace.

Join now and transform your skills from novice to professional in Serverless technology in minimal time!

Additional

CDK, Terraform, and Serverless Framework. The online player features lessons from the CDK version of the course. The full course archive includes all three versions, each separated. Same for materials.

About the Author: Yan Cui

Yan Cui thumbnail

Yan Cui is a UK-based AWS Hero and one of the most authoritative independent voices on serverless architecture on AWS — particularly Lambda, the surrounding event-driven stack (EventBridge, SQS, Step Functions), and the operational patterns for production serverless systems. He runs theburningmonk.com and consults extensively on serverless architecture.

His CourseFlix listing carries Production-Ready Serverless — a comprehensive treatment of building production serverless systems on AWS: the architectural patterns, the testing strategies for serverless code, observability, the cost-and-cold-start trade-offs, and the engineering decisions for serverless at scale.

Material is paid and aimed at engineers building production serverless systems. For broader content, see CourseFlix's AWS category page.

Watch Online 83 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 83 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: What do we mean by serverless?
All Course Lessons (83)
#Lesson TitleDurationAccess
1
What do we mean by serverless? Demo
09:00
2
When is serverless the right choice for your workload?
08:48
3
The serverless-first mindset
01:52
4
What about vendor lock-in?
04:19
5
Prerequisite: Adding an IAM user
02:40
6
Lambda 101
54:36
7
How Lambda works under the hood
07:55
8
Understanding Lambda's scaling behaviour
03:30
9
Lambda EFS integration
08:48
10
Lambda extensions
11:03
11
Intro to Provisioned Concurrency
07:10
12
When to use Provisioned Concurrency
06:00
13
When to use Lambda destinations
03:46
14
CloudFormation 101
06:46
15
IAM 101
08:30
16
Serverless Framework vs AWS SAM vs AWS CDK vs Terraform
12:17
17
Introduction to AWS CDK
05:43
18
Ephemeral (Temporary) environments explained
11:31
19
DynamoDB 101
06:46
20
API Gateway 101
04:26
21
Securing API Gateway
15:07
22
Cognito 101
03:13
23
Secure API Gateway with Cognito User Pool
01:16
24
API Gateway best practices
10:41
25
API Gateway REST API vs HTTP API vs ALB
02:29
26
When to use Lambda function URLs
10:30
27
How to assign a static IP to a Lambda function
03:07
28
When to use API Gateway service proxies
05:12
29
Live Q&A #1
59:17
30
Live Q&A #2
01:06:54
31
The general strategy for testing API Gateway REST APIs
06:52
32
Bye bye testing pyramid, hello testing honeycomb
06:39
33
Unit vs Integration vs End-to-End tests
09:02
34
Hexagonal architectures the what why and when
07:07
35
Use Remocal tests to make integration tests fast and reliable
09:21
36
Writing end-to-end tests
02:08
37
CI/CD
08:11
38
Intro to SSM Parameter Store
06:49
39
Ephemeral (Temporary) environments explained
11:31
40
Securely handle secrets
02:43
41
SSM Parameter Store vs Secrets Manager
06:12
42
How to handle serverful resources when using ephemeral environments
02:42
43
How to load test serverless apps
04:42
44
How to organize your system into repositories
06:31
45
Best practices for AWS Organizations and accounts
07:59
46
Live Q&A #3
39:14
47
Live Q&A #4
01:00:48
48
Introduction to Event-Driven Architectures
02:21
49
Introduction to Domain-Driven Design
03:54
50
Introduction to EventBridge
10:33
51
Comparing EventBridge event bus topologies
06:54
52
Processing events with EventBridge and Lambda
03:59
53
How to include SNS and EventBridge in end-to-end tests
04:54
54
Dealing with failures
13:15
55
SNS vs SQS vs Kinesis vs EventBridge
05:08
56
How to control Lambda concurrency
07:42
57
How to structure and version your events
03:35
58
Events vs Commands
05:33
59
Light event vs. Rich event
05:07
60
Domain vs Integration events
05:52
61
Context Mapping and Anti-Corruption Layers
09:27
62
Where should you implement the Anti-Corruption Layer?
02:02
63
Do you need an event broker
03:22
64
How to forward events to a data lake
03:54
65
Introduction to event sourcing
05:31
66
Introduction to CQRS
05:01
67
Orchestration vs Choreography
05:59
68
Introduction to AWS Step Functions
06:23
69
Introduction to Amazon States Language (ASL)
09:13
70
Designing an order processing workflow with Step Functions
21:47
71
Live Q&A #5
28:37
72
Log aggregation
09:34
73
Structured logging
01:14
74
Sample debug logs in production
01:58
75
Lambda's advanced logging controls
04:38
76
Intro to AWS X-Ray
09:19
77
X-Ray limitations
06:33
78
Intro to Lumigo
12:12
79
Alerts you should have
06:29
80
Introduction to LLRT
03:28
81
How to build multi-region, active-active serverless applications
03:42
82
All you need to know about caching for serverless applications
10:13
83
Costly mistakes to avoid
06:00
Unlock unlimited learning

Get instant access to all 82 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for enrolling in this course?
Before enrolling in the course, it is recommended that students have a basic understanding of AWS services, as the course covers specific AWS tools such as IAM, Lambda, API Gateway, and DynamoDB. Familiarity with cloud computing concepts will also be beneficial. The course includes a lesson on adding an IAM user, which serves as an essential starting point for managing AWS resources.
What kind of projects will I work on during the course?
Throughout the course, students will engage in practical exercises involving serverless applications. Lessons cover topics like Lambda function deployment, API Gateway integration, and the use of AWS CDK for infrastructure management. These projects will help you develop skills in creating and optimizing serverless applications ready for production use.
Who is the target audience for this course?
This course is designed for IT professionals and developers who want to specialize in serverless architectures using AWS. It is ideal for those who wish to deepen their understanding of serverless technologies and become experts in deploying and managing serverless applications in production environments.
How does this course compare to others in terms of depth and scope?
This course provides a detailed exploration of serverless architectures, focusing on AWS tools and best practices. With 83 lessons, it covers a wide array of topics including Lambda, API Gateway, CI/CD, and EventBridge, offering comprehensive training compared to other courses that may only touch on these areas briefly. It is particularly suited for those looking to gain deep insights into serverless application deployment and optimization.
What specific tools and platforms are taught in the course?
The course focuses on AWS services and tools such as Lambda, API Gateway, DynamoDB, and IAM. It also covers infrastructure management using AWS CDK, serverless frameworks, and comparisons with AWS SAM and Terraform. Practical lessons on securing and monitoring these services are included to provide a well-rounded understanding of serverless environments.
What topics are not covered in this course?
While the course provides extensive coverage of AWS-related serverless technologies, it does not delve into non-AWS cloud platforms such as Microsoft Azure or Google Cloud Platform. Additionally, topics like traditional server-based architectures and non-serverless deployment strategies are not covered, as the focus remains on serverless solutions.
How much time should I expect to commit to this course?
The course consists of 83 lessons, with the expectation that students engage in both theoretical and practical exercises. While the total runtime of the course is listed as 00:00:00, this likely indicates ongoing updates and content additions. Students should be prepared to dedicate several hours per week to complete the lessons, practical exercises, and any additional reading or practice needed to fully grasp serverless concepts.