Sign up to be notified of the release of the reInvent 2020 Review, including live Q&A with Yan Cui on Friday 11 December 12:30 PST, and other Homeschool by Senzo courses and promotions.

Thank you!

Thank for you signing up. Check your inbox for updates and access to the platform.

Testing Serverless Applications

No classes scheduled

Learn useful testing approaches for serverless apps in this 2 week course taught by Slobodan Stojanović & Aleksandar Simovic.

According to many polls, testing serverless applications and fear of the cloud vendor lock-in are among the top five challenges organisations are facing when adopting serverless. We often hear that using serverless effectively requires a mind shift. But what does that mean? Do we need new tools and strategies for testing serverless applications, or can we use existing tools we already use for our non-serverless applications?

We will learn which approach to take on testing serverless applications, how to prepare our app for testing, and how to write tests. We'll start with unit tests, then gradually learn how to write integration and end-to-end tests. In addition, in this workshop we'll also learn how to write testable serverless functions without sacrificing our organisation's speed and agility. To accomplish that, we'll use the tools that we are using today, and an architecture that we probably heard of before: hexagonal architecture, also known as "Ports and Adapters".

Finally, we'll see how this new architecture will also help us to fight vendor lock-in.


No classes scheduled

Testing serverless apps vs non-serverless apps

Learn how testing serverless apps differs, covering the testing pyramid, unit tests and an intro to how to write testable serverless functions using Hexagonal Architecture.

Woman Sitting
Week 1
Intro to testing serverless applications
Testing pyramid vs. Serverless testing pyramid
Unit tests
Writing testable serverless functions - introduction to hexagonal architecture
Man Walking

Integration and end-to-end tests, and how testing helps avoid vendor lock-in.

This week we will learn how to deploy integration and end-to-end tests, making good decisions about what to test without being slowed down and finally, how using Hexagonal Architecture helps you avoid vendor lock-in. We will then wrap up the course and demonstrate some real examples.

Week 2
Integration tests
How to decide what to test
Using hexagonal architecture in a way that does not slow you down
End-to-end tests
How hexagonal architecture helps you fight vendor lock-in


The class takes place over 2 weeks, with an average time committment of 4-5 hours per week. Each week will follow this structure:

Mondays: Lectures and exercises released via the Homeschool platform; you'll need to be logged in to access this.

All week: Peer chat and exercise sharing via Discord server with your instructor and class cohort.

Thursday evening, 10pm and Friday morning, 10am CET: Live recap and Q&A sessions (~1 hour) with the instructors. Exercise answers released. The Q&A session is streamed within the Homeschool platform, with questions submitted via Discord. All questions are logged and a timecode for the start of the answer is shared on the platform after the stream ends. The Q&A sessions are viewable permanently afterwards, in case you miss them.

All course materials are permanently available on your Homeschool account after they've been released.

What you'll need...

A brief list of what you will need to do this class:

  • A basic understanding of Amazon Web Services (AWS) and how it works.
  • A basic experience with serverless on AWS. Creating and running a few Lambda functions is enough.
  • A laptop with a terminal emulator. For example, Mac Terminal, iTerm2, Microsoft Terminal, or any other.
  • A code editor or IDE. For example, VS Code, Sublime, Vim, Emacs, Visual Studio, IntelliJ, etc.
  • An active AWS account. All examples will work on the AWS Free Tier if you have a new account.
  • Previous experience with Node.js, as most of the examples will be in Node.js, though it is not required.

Who it's for...

If you've ever built and run at least one serverless function, there's a big chance that you read about testing serverless applications, or tried to test your code. This workshop is built to help you with testing serverless apps and writing testable serverless functions. It is especially helpful for:

Backend Engineers whose primary focus is building business logic and managing APIs and data processing pipelines. Particularly useful for engineers who are planning a migration to serverless or running part of the application on serverless.

Fullstack engineers who have to dabble with both frontend and backend technologies and who increasingly need to be fluent with AWS and its serverless offerings.

Frontend engineers experienced with testing using one of the popular testing frameworks (such as Jest, Jasmine, or Mocha), who want to learn the basics of serverless.

Tech Lead, Architects, and Engineering Managers who want to get a deeper understanding of testing serverless applications so they can better help their teams make the best architectural decisions and solve architectural challenges they face.