4.61 out of 5
5240 reviews on Udemy

AWS Serverless APIs & Apps – A Complete Introduction

Get into serverless computing with API Gateway, AWS Lambda and other Amazon Web Services! Zero server config APIs & SPAs
Academind by Maximilian Schwarzmüller
30,780 students enrolled
English More
Build, secure and run APIs without managing any servers using AWS API Gateway and Lambda
Host SPAs without managing any servers
Add user authentication to serverless applications
Run code on-demand in the cloud

Serverless computing will shape the future of web development since it allows you to get rid of many issues “traditional” web hosting poses. Now’s the time to dive into this exciting new technology!

Unlike in traditional web hosting, where you spin up servers, configure them and then deploy your code, in serverless applications, you don’t manage any servers! Instead, you only provide your code and define when it should get executed. Done!

Without managing any servers, you typically pay way less (since you got no overhead capacity), can react much better to incoming traffic spikes and don’t have to worry about server security!

For these very reasons, it’s no wonder that serverless computing is on the rise, with more and more companies adopting it! Learn it now to gain an edge and either use it for your own projects or apply for high-paid jobs!

What does this course offer then?

This course will introduce you to serverless computing and then quickly dive into how to build serverless apps with Amazon Web Services (AWS).

Specifically, you will learn:

  • how you can build a REST API without worrying about servers, using AWS API Gateway
  • to set up your on-demand code via AWS Lambda 
  • how to execute that Lambda code whenever incoming requests reach your defined REST endpoints
  • how you can store data in a database – naturally without managing any database servers!

We won’t stop there though! Instead, you’ll then dive even deeper into serverless computing and learn:

  • how you can add user authentication to your existing frontend apps and how you can then also protect your REST API against unauthenticated access with ease!
  • how you can easily integrate a complete user sign up & sign in flow (including user confirmation) into ANY app (web app, iOS or Android app!) with AWS Cognito
  • how to deploy your web app in a serverless manner
  • how to speed up the delivery of your static web app assets
  • how to secure your serverless app
  • what else you can build with the services covered in this course and which other services might be interesting to you
  • where to dive deeper regarding advanced development workflows 
  • and much more!

Is this course for you?

Now that you know what this course offers, is it the right choice for you? Which skills should you bring?

This course is absolutely the right choice for you if you’re interested in providing great web applications without worrying about the provisioning of servers.

It’s also the right choice if you already got experience as a system administrator but are interested in keeping up with the latest developments and the many new possibilities serverless computing offers.

You will need some basic AWS knowledge, or the willingness to dive deeper into AWS alongside taking this course. Additionally, a credit card is required for signing up to AWS.

Finally, you should be familiar with APIs and SPAs (Single-Page-Applications) and which role they play in today’s web development environment. You don’t need to know how to create them though.

I’d be very happy to welcome you on board! 

Getting Started


Let me introduce you to this course, its goals and what you're going to learn!

What is AWS?

We learned what Serverless Computing is - but what's AWS?

AWS - A Closer Look (Optional)
What is Serverless Development?

This course is about serverless computing. But what does that actually mean? This lecture takes a closer look.

Does AWS Cost Money?

Let's clarify one important question right at the start!

AWS Signup & First Serverless API

With the theory out of the way, let's build our first serverless API. For that, we'll need an account though - time to create one!

Why AWS?

This course covers AWS - are there no alternatives? Yes there are, this lecture outlines why AWS is chosen amongst them.

Course Structure

This lecture will walk you through the structure of the course and show what you can expect from it.

How to get the Most out of this Course

Obviously, you want to get the most out of this course. In this lecture, I'll share some extremely important guidelines on how to achieve that.

How to use the File Downloads

In this course, I provide a couple of files for download (e.g. lambda code files). Learn how to use these files in this lecture.

The Core Serverless Services

Module Introduction

Let me introduce you to this course module and what we're going to cover in it.

An Overview over the Core Serverless Services

Which AWS services are actually involved when creating a serverless app? This lecture dives into that question.

More Info about the Core Services

You got the bigger picture and we'll dive into the services in detail throughout the course. In case you don't want to wait that long, you can check out this lecture though.

The Course Project

Theory is nice but it's extremely important to also see how the things come together in practice. That's why we'll build a complete project in this course. Learn more about it in this lecture.

Creating an API with API Gateway & AWS Lambda

Module Introduction

Let me introduce you to this course module and its content.

What is API Gateway?

Let's dive into the first service we'll cover in this course: AWS API Gateway. What is it and which roles does it play in a serverless app?

API Gateway: Useful Resources & Links

We're going to dive into API Gateway, no worries. Still, it's never too early to share some useful links!

Accessing the API Gateway Console

This lecture teaches you how to access the API Gateway console, the main tool we're going to work with in this course.

General API Gateway Features

Let's dive into API Gateway and take a closer look at its general features in this lecture!

Understanding AWS Permissions (IAM)

AWS by default doesn't grant any service any permissions. This is news to you? Have a look at this article then!

API-specific Features & Options

After having a look at the general API features and options, let's now examine what we can configure for the individual APIs we create.

Introducing the Request-Response Cycle

Each request which reaches API Gateway follows a certain cycle. Learn more about this cycle in this lecture.

Understanding the Request-Response Cycle

We got started with the Request-Response-Cycle in the last lecture, let's now dive deeper into it!

Creating a New API

Enough about the theory, it's time to create our first API. Learn how that works in this lecture.

Creating a Resource (= URL Path)

Having an API is nice but we also need resources (paths). This lecture shows how you can quickly create and configure such resources.

Handling CORS and the OPTIONS Preflight Request

When creating resources, we also have to keep CORS in mind, otherwise our frontend (web) apps won't be able to connect. Learn more about this matter in this lecture.

Creating a (HTTP) Method

With a resource created and CORS configured, it's time to handle Http methods. Learn how to register a method handler in this lecture.

What is AWS Lambda?

We finished our first steps in API Gateway. Thus far, we only mock data - time to change that and create our first lambda function!

AWS Lambda: Useful Resources & Links

Just as with API Gateway, here's a little collection of helpful links in case you want to dive into more details or plan on playing around with Lambda on your own.

Improved Lambda Console

AWS enhanced the Lambda console - learn what's new!

Creating a Lambda Function
Lambda Pricing & Uploading Code

We created a basic Lambda function but what, if you don't want to use the In-line code editor? You can simply upload a ZIP file!

Connecting Lambda Functions to API Gateway Endpoints

We got a Lambda function and we got API endpoints. Time to connect both!

Accessing the API from the Web & Fixing CORS Issues

Let's few our progress by accessing our API from the web. We'll also have another look at CORS for that.

Time to Practice - API Gateway + Lambda Basics
Understanding "event" in Lambda Functions

We got a working Lambda function - but what is this event object actually all about?

Forwarding Requests with "Proxy Integration"

This lecture explores an alternative way of getting your requests to lambda: Directly forwarding them.

Accessing Lambda Logs

How can we find out what's happening inside our function? By checking its logs! Learn how to do this in this lecture.

Getting Started with Body Mapping Templates

We learned how we can forward requests to Lambda. There's a better way of getting data into Lambda though. Learn more about that way in this lecture.

Extracting Request Data with Body Mapping Templates

We learned about Body Mapping Templates. This lectures takes a closer look at how we actually extract request data with them.

What's the Idea behind Body Mappings?

We took a closer look at Body Mapping templates. What's the core idea behind them?

Understanding Body Mapping Templates

Body Mapping Templates can be confusing but in the end, you often can stick to very simple ones. Let's take a closer look in this article.

Mapping Response Data

We're not limited to mapping request data - we can also map the response as this lecture shows.

Using Models & Validating Requests

With mapping templates covered, let's turn to "Models". What are these about? This lecture sheds some light on them.

Understanding JSON Schemas

We use JSON Schema Language to create a model schema in API Gateway. What's this language all about? Learn more in this article.

Models & Mappings

Models can be combined with mapping templates. This lecture explores how that works.

Time to Practice - Models and Mappings
Next Steps

Time to take a quick break and plan the next steps.

Adding a DELETE Method Endpoint to the API

Let's get back to adding resources and methods - time to add a DELETE method to our API!

Using Path Parameters

So far, we only considered static paths. You can also use dynamic ones though. This lecture shows how to get started with dynamic paths.

What about Query Parameters?

If we're talking about Path Parameters, we also have to take a look at Query Parameters, don't we? This lectures dives into them.

Accessing the API from the Web - The Right Way

The API is taking shape! Time to again test it from the web - with the correct data being passed to it.

Wrap Up

Let me wrap this module up and summarize it for you!

Data Storage with DynamoDB

Module Introduction

Let me introduce you to this module.

What is DynamoDB?

In this module, we're going to have a look at a database solution so that we're able to store some data. DynamoDB is going to be a good choice but what is it actually?

AWS: DynamoDB Useful Resources & Links

As always, don't miss your chance to dive into the official docs and learn more about DynamoDB.

How DynamoDB Organizes Data

We got a first impression of DynamoDB, this lecture will now dive deeper into that service and explain how data is organized in DynamoDB.


DynamoDB is a NoSQL database. Is that better or worse than SQL? What's the difference? Let's take a closer look in this lecture.

Using DynamoDB with Lambda

DynamoDB is more fun if we use it together with other services - like Lambda! This lecture explores how the two services may work together.

Creating a Table in DynamoDB

Enough about the theory, let's see how that all works in practice. What better way to start than to create a new table?

Understanding Read & Write Capacity

DynamoDB uses Read & Write Capacity to charge you. What does that mean and how does that work? This lecture takes a closer look.

On-Demand Capacity
Creating and Scanning Items

We got a table, we need items! This lecture will explore how you may add items to your DynamoDB table and how you can then scan them.

What about multiple Databases?

DynamoDB uses multiple tables, we got that. But can you also use multiple databases?

Accessing DynamoDB from Lambda

Time to use our table from our Lambda function. This lecture teaches you how you may easily access DynamoDB from Lambda!

DynamoDB Concepts

Did you understand the basic concepts of DynamoDB? Do you know how to work with it? Let's find out!

Sidenote: How Lambda works behind the Scenes

To understand the code we wrote in the last lecture, we also need to understand how Lambda works behind the scenes. This lecture explores that question.

Putting Items into a DynamoDB Table from Lambda

We're already accessing DynamoDB from Lambda, time to make the next step and actually put an item there!

Setting Permissions Right

In order to access DynamoDB from Lambda, we need to set the right permissions. And we can do better than we did thus far. Time to improve our permission settings.

Using API Gateway (Request) Data for Item Creation

Let's connect it all! Time to use the data from API Gateway in Lambda to finally create an item in DynamoDB fueled by that request data.

Mapping the Response & Web Testing

We put data into our DynamoDB, let's no work on the response Lambda returns. It's also time to see how that all works in a web app.

Scanning Data in DynamoDB from Lambda

Adding data is nice but of course we also want to get that data back. Nothing easier than that! In this lecture, you'll learn how to scan your DynamoDB tables from Lambda.

Improving the IAM Permissions

We already made sure that Lambda has the right permissions to access DynamoDB, but we can do far better and only provide the permissions Lambda actually needs. Time to do that!

Restructuring Fetched Data in Lambda

We're scanning a DynamoDB table - the yielded data can now be restructured inside of Lambda. This lecture explores how we may do that.

Getting a Single Item from DynamoDB via Lambda

Scanning gives us ALL items. What if we only want one specific item? This lecture shows how that works.

Testing it from the Web & Passing Correct Data

With all Lambda functions finished, it's now time to test it all from the web and see if it all works as expected. We'll also take a look at how the request needs to be sent.

Preparing "Delete" Permissions

Adding and getting data is nice but ultimately, we also want to be able to delete data. In this lecture, we'll prepare the permissions for that!

Giving Lambda Logging Rights

We improved the permissions but Lambda now is not able to create logs. If you do want it to do so, have a look at this article.

Deleting Items in DynamoDB via Lambda

We added and retrieved data, now it's time to also delete data which is stored in DynamoDB.

Mapping DynamoDB Responses

With all methods implemented, it's time to do some polishing and map some DynamoDB responses into "better" ones.

Wrap Up

Let me wrap this module up and summarize what we learned.

Authenticating Users with Cognito and API Gateway Authorizers

Module Introduction

Let me introduce you to this module.

How to add Authorization to API Gateway

This lecture dives into how we may add authorization to API Gateway endpoints.

Understanding Custom Authorizers (API Gateway)

When we talk about protecting API Gateway Endpoints, we of course have to look at the features it offers us. Custom Authorizers are one of these features. Let's learn what these are about!

Creating a Custom Authorizer Function

Now that we learned what custom authorizers are, it's time to dive into building our first custom authorizer function.

Custom Authorizers: Provided Input & Expected Output

When creating custom authorizers, there is a set of input data you will receive and a certain format of output data you should provide. Learn more about that in this lecture.

MUST READ: New UI for setting up Custom Authorizers

Make sure to read this lecture to avoid errors when setting up the cognito authorizer.

Using Custom Authorizers

We got our own authorizer function finished, with that, it's time to use it!

Retrieving Users from Custom Authorizers

It's great that we can control who's allowed to access our resources and who's not. But it would be even better if we could also retrieve the user who was granted access!

What is AWS Cognito?

With the basics about authorization explained, it's time to do the next step and see how we can also add a complete auth (sign up + sign in) flow to our existing apps. Learn how AWS Cognito helps you with that!

AWS Cognito: Useful Resources & Links

We're using AWS Cognito in this module - time to share some useful links.

Cognito User Pools and Federated Identities

AWS Cognito actually consists of two parts. Learn more about these parts in this lecture!

Creating a Cognito User Pool

With the basics about Cognito (and Cognito User Pools) set, let's now dive into creating our first User Pool!

Understanding the Cognito Auth Flow

AWS Cognito handles a lot of things for your, it's key to understand what it does though! This lecture explores the Cognito Auth Flow.

The Example Web App, Angular and TypeScript

We're going to add Cognito to an example web app in this course. The app is built with Angular. No worries, you don't need to know Angular!

You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
4.6 out of 5
5240 Ratings

Detailed Rating

Stars 5
Stars 4
Stars 3
Stars 2
Stars 1
30-Day Money-Back Guarantee


8 hours on-demand video
30 articles
Full lifetime access
Access on mobile and TV
Certificate of Completion