What Are AWS Lambda Triggers?

This is a basic introduction to Lambda triggers that uses DynamoDB as an event source example.

We talk a lot about the more advanced level of Lambda triggers in our popular two-part series: Complete Guide to Lambda Triggers. If you want to learn more, read part one and part two.

We’re going back to the basics this time because skipping some steps when learning something new might get you confused. It tends to get annoying, or it can even make you frustrated. Why?

To understand how something works appropriately and later on to know how to apply your knowledge practically without stress, you must master the particular subject in a particular order.

Let me put it this way: you can’t calculate how fast is a subatomic particle moving in space if it’s 300 lightyears away from the closest planet if you don’t know the basic math, like 3.14 times 42, right?

So, back to our topic here, what are AWS Lambda triggers?

AWS Lambda monitoring

Lambda Triggers Explained with DynamoDB Integration

DynamoDB is an AWS product just like Lambda, and therefore you’re able to create triggers with ease. Triggers are pieces of code that will automatically respond to any events in DynamoDB Streams.

Triggers allow you to build applications that will then react to any data modification made in DynamoDB tables. By enabling DynamoDB Streams on a table, you will be able to associate an ARN with your Lambda function. Instantly after an item in the table is modified, a new record will appear in the table’s stream. When AWS Lambda detects a new stream record, it will invoke your Lambda function synchronously.

Lambda functions can perform any actions you specify, like sending notifications or a workflow initiation.

An example: suppose you have a mobile gaming app that’s writing on a GameScores table. Each time the TopScore attribute of the GameScores table is updated, a corresponding stream record will be written to the table’s stream. You can then set a Lambda function to post a message on social media sites once the event is triggered.

Event-Driven Lambda And How To Trigger It

For Lambda functions to execute, an event must occur (think If, Then). If an event happens, then it will trigger Lambda. Until recently, our knowledge of triggering Lambda functions was based on API Gateway as a trigger, but more AWS resources can trigger your Lambda functions.

Events can be anything happening with the resources within your AWS account. Did somebody write a record to DynamoDB? This can trigger a Lambda function. Did someone upload a file to S3? This can be a Lambda trigger too.

Lambda Triggering Another Lambda – A Bad Decision?

You can even call Lambda functions from other Lambda functions! But this is generally seen as bad practice. If you don’t finish your Lambda before you start the next one, you pay for both running. The first one that is waiting for the second one and the second one. Think about optimizing your lambdas for performance and cost.

You should always put another service between your Lambda functions and don’t call them directly. SQS, SNS, and Step Functions are good ways to connect your Lambda functions without paying for two invocations at once.

How to Trigger a Lambda Manually?

If you ever want to trigger lambdas “manually” then simply create an event using one of the AWS resources.

How to Trigger a Lambda Function? 3 Common Ways To Trigger Lambda

To trigger a lambda function, you can choose between many different ways. The 3 most common ways are API Gateways, S3, and DynamoDB table streams.

API Gateway

API Gateway event is one way to trigger Lambda. These events are considered synchronous events. Simply put, it means that when somebody is calling an API Gateway, it will trigger your Lambda function. It’s a synchronous event because your Lambda function has to respond to the client directly at the end of its invocation. For Lambda to know which kind of event will trigger it, you need to define it in the configuration or, or serverless.yml if you’re using the Serverless Framework.


S3 events occur when someone (or something) modifies the content of an S3 bucket. Altering the content can be achieved by either creating, removing, or updating a file. While you’re defining an event, you’re able to specify what sort of action will trigger the lambda function, whether it’s creating, removing, or updating a file.

S3 events are asynchronous, which means your Lambda function only has to handle the event and doesn’t have to respond with anything. There is no client involved like with API Gateway, so nobody is waiting for your function to send a response. S3 will send an event that triggers your Lambda function, but it won’t check what it did afterward.

DynamoDB Table Streams

DynamoDB events will be explained shortly, but first, let’s start with DynamoDB table streams.

A DynamoDB table stream is like a line or a queue through which the data flows. In this particular case, the data is actually the change made to a specific table. This means that when someone updates a record in a specific DynamoDB table, it will instantly publish all of these changes in a stream, and it further implies that the Lambda function will be triggered because there is data in the stream.

This way is a little bit more complicated since we need to connect the Lambda function to a DynamoDB stream. When there is data in the stream, there are two different ways Lambda will get triggered by it.

First, when there is any kind of data in the stream, which means a single change to the database at a certain time, the lambda will be executed only once.

The second way table streams trigger Lambda functions is when there is a batch of events in the stream, all processed together. This way saves the execution time a lot since processing streams are pretty fast.

Like S3 events, table stream events are asynchronous, so you don’t have to send a response from your Lambda function. They differ from S3 events in their second way to trigger Lambda functions, which allows you to batch multiple DynamoDB changes into one Lambda event.

Bonus: List of Lambda Event Sources

Here is a small list of AWS services that can trigger events for AWS Lambda.

Let’s start with the synchronous event sources. These require your Lambda function to return a response when it’s finished. This is because the service that triggered the event sends the response to a client or uses it to check if the event was handled successfully.

  • Elastic Load Balancing (Application Load Balancer)
  • Amazon Cognito
  • Amazon connect
  • Amazon Lex
  • Amazon Alexa
  • Amazon API Gateway
  • Amazon CloudFront (Lambda@Edge)
  • Amazon Kinesis Data Firehose
  • Amazon Simple Storage Service Batch

And now the services that trigger asynchronous events. These are simply fire-and-forget; the services that triggered the events don’t care if your Lambda function handled them correctly. If you need retry logic, you have to implement it yourself with the help of SQS or Step Functions.

  • Amazon Simple Storage Service
  • Amazon Simple Notification Service
  • Amazon Simple Email Service
  • AWS CloudFormation
  • Amazon CloudWatch Logs
  • Amazon CloudWatch Events
  • AWS CodeCommit
  • AWS Config
  • AWS IoT
  • AWS IoT Events
  • AWS CodePipeline


AWS Lambda triggers are merely actions caused by specific AWS resources; these actions generate events that will further execute Lambda functions that listen to them.

AWS Lambda is an event-based system. Lambda functions are associated with events that are triggered by other AWS resources, like API Gateway, S3, or DynamoDB. Lambda functions will always react to these events.

Once you have finished reading about triggers, you will probably start to wonder about the observability aspect of your serverless app or, to put it better, the lack thereof. You wouldn’t be the first one to think like that, but luckily several services can help you in that regard.

Dashbird can help you monitor your AWS Lambdas with an all in one easy-to-understand dashboard. Set up alerts, get insights on what to improve, and keep track of costs without adding any strain to your application. You can sign up right now to start monitoring your serverless app for free! No code changes and no credit card required.

Dashbird Book

Get your free Ebook!

Serverless Best Practices handbook

Further reading:

The Complete AWS Lambda Handbook for Beginners (part 1/3)

Using Lambda Layers for Better Serverless Architecture

Monitoring vs Observability: can you tell the difference?

AWS Lambda Error Handling

Why AWS Console isn’t Always the Best for Serverless Debugging?

Read our blog

ANNOUNCEMENT: new pricing and the end of free tier

Today we are announcing a new, updated pricing model and the end of free tier for Dashbird.

4 Tips for AWS Lambda Performance Optimization

In this article, we’re covering 4 tips for AWS Lambda optimization for production. Covering error handling, memory provisioning, monitoring, performance, and more.

AWS Lambda Free Tier: Where Are The Limits?

In this article we’ll go through the ins and outs of AWS Lambda pricing model, how it works, what additional charges you might be looking at and what’s in the fine print.

More articles

Made by developers for developers

Dashbird was born out of our own need for an enhanced serverless debugging and monitoring tool, and we take pride in being developers.

What our customers say

Dashbird gives us a simple and easy to use tool to have peace of mind and know that all of our Serverless functions are running correctly. We are instantly aware now if there’s a problem. We love the fact that we have enough information in the Slack notification itself to take appropriate action immediately and know exactly where the issue occurred.

Thanks to Dashbird the time to discover the occurrence of an issue reduced from 2-4 hours to a matter of seconds or minutes. It also means that hundreds of dollars are saved every month.

Great onboarding: it takes just a couple of minutes to connect an AWS account to an organization in Dashbird. The UI is clean and gives a good overview of what is happening with the Lambdas and API Gateways in the account.

I mean, it is just extremely time-saving. It’s so efficient! I don’t think it’s an exaggeration or dramatic to say that Dashbird has been a lifesaver for us.

Dashbird provides an easier interface to monitor and debug problems with our Lambdas. Relevant logs are simple to find and view. Dashbird’s support has been good, and they take product suggestions with grace.

Great UI. Easy to navigate through CloudWatch logs. Simple setup.

Dashbird helped us refine the size of our Lambdas, resulting in significantly reduced costs. We have Dashbird alert us in seconds via email when any of our functions behaves abnormally. Their app immediately makes the cause and severity of errors obvious.