FaaS & BaaS


  1. What is Serverless?
  2. Why Serverless?
  3. Road to Serverless
  4. Functions as a Service
  5. FaaS: Under the Hood
  6. Best Practices
  7. Exercises

What is Serverless?




Server maintenance is responsibility of user

Server maintenance is responsibility of provider

Why Serverless?

Why Serverless?

Serverless is about focusing your efforts on what provides value to users. Upgrading your Linux distro does not provide value to users. Managing your RabbitMQ servers does not provide value to users. Shipping product provides value to users.

That is the serverless maxim: focus on business logic, not servers.

Road to Serverless

On Premise Servers


  • Needs staff to maintain the system


  • Servers must be bought upfront


  • High level of control

Infrastructure as a Service

  • Provider manages hardware


  • Provides a base OS


  • User maintains and updates software


  • Scales vertically and horizontally

Platform as a Service


  • User just selects the runtime


  • OS and virtualization managed by provider


  • Scales horizontally and vertically

Backend as a Service


  • Common features provided as APIs or SDKs


  • Very fast development


  • Provider maintains infrastructure and software

Functions as a Service

  • User just writes a function


  • Based on ephemeral containers


  • Scales easily


  • Pay-per-use




Functions as a Service


Run code without thinking about servers. Pay only for the compute time you consume.

AWS Lambda

General Architecture




File Upload

Database Update

New Message in a Queue

New Commit to Repo

Scheduled Events



  • Scalability
  • Focus on Business Logic
  • Fault-tolerance
  • Security
  • Pay per use


  • Cold Starts
  • Vendor lock-in
  • Lack of Control
  • Testing

Use Cases

  • Event-based Architectures
  • Expensive and Spontaneous Computations
  • Variable Demand Systems

Under the Hood

Your Code

Lambda Runtime


Guest OS


Host OS


Amazon Linux

Node, Python...

Lambda Function

AWS EC2 Metal


AWS Lambda Init

Development Tools

  • Official tool by AWS
  • Only for AWS
  • Allows local testing for Lambda functions
  • Permits event generation for other AWS services
  • Unofficial tool
  • Provider-agnostic
  • Allows local testing for various services
  • Has a great variety of plugins

Best Practices

Keep Functions Stateless

const AWS = require('aws-sdk'),
const uuid = require('uuid'),
const documentClient = new AWS.DynamoDB.DocumentClient(); 

exports.handler = function(event, context, callback){
  const params = {
    Item: {
      id: uuid.v1(),
      firstName: event.firstName,
      lastName: event.lastName,
    TableName: 'people'

  documentClient.put(params, function(err, data){
    callback(err, data);

Use permanent data stores like databases to store state

Separate Business Logic

exports.handler = function(event, context, callback) {
  const foo =;
  const bar =;
  const result = myLambdaFunction (foo, bar);
  callback(null, result);
function myLambdaFunction (foo, bar) {
  // your logic here

Separate your business logic from vendor-specific handler

Use the Execution Context

const mysql = require('mysql');
const connection = mysql.createConnection({
  host     : 'localhost',
  database : 'my_db'

connection.on('error', function(err) { connection.connect(); });

exports.handler = function(event, context, callback){
  connection.query('SELECT * FROM people', function (error, results, fields) {
    if (error) {
      callback(error, null);

    callback(null, results);

Reuse connections between calls to the same function

Monitor Memory Usage

A higher memory tier may be more expensive, but the execution time may be shorter

Hello World

Install Serverless

$ npm install -g serverless

Create Project

$ mkdir serverless-hello-world
$ cd serverless-hello-world
$ sls create --template aws-nodejs

Install Serverless Offline

$ npm install serverless-offline --save-dev

Enable Serverless Offline

## serverless.yml

service: aws-nodejs

## Add these two lines
  - serverless-offline


Setup HTTP Route

## serverless.yml

    handler: handler.hello
    events: ## Add these four lines to setup the HTTP route
      - http:
          path: /
          method: get


$ sls offline start
Serverless: Starting Offline: dev/us-east-1.

Serverless: Routes for hello:
Serverless: GET /

Serverless: Offline listening on http://localhost:3000

1st Exercise

Note Taking API

Should be able to:

  • Create note
  • Get note by ID
  • Get all notes
  • Update note
  • Delete note


Useful Material

2nd Exercise

HTML-based Visual Testing

Endpoint /store should be able to:

  1. Store HTML files in AWS S3 with an ID


Endpoint /diff should be able to:

  1. Retrieve HTML from S3 given the ID
  2. Render HTML files with Chrome
  3. Screenshot rendered files
  4. Diff screenshots
  5. Return whether screenshots match or not


Useful Material

Interesting Resources

Serverless: FaaS & BaaS

By Bernardo Belchior

Serverless: FaaS & BaaS

  • 943