Resources · Make integration

Amazon Lambda Make integrationAutomate Amazon Lambda with Make.

Can your Lambda functions run from a scenario without writing glue code? The Amazon Lambda Make integration gives you 9 modules: 2 triggers, 4 actions and 3 searches. This page shows how to link your AWS account, build a first scenario and pick the right module.

Try the Amazon Lambda integration on MakeSee the 9 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What does the Amazon Lambda Make integration do?

The Amazon Lambda Make integration links your AWS account to Make so a scenario, the automation you build in Make, can watch your functions and layers, read their details and invoke a function. Each step is a module: one brick of the scenario, such as a trigger, an action or a search.

Run a function after it changes. Watch Functions notices a function that was updated since its last check, and Invoke a Function starts it in the same run, so fresh code runs without anyone opening the AWS console.

Keep an inventory of what runs. List Functions returns every function of the account as separate bundles, one item per function flowing to the next module. Paired with Get a Function, it feeds a sheet or a report your team can read without AWS access. The same idea works for shared code with List Layers and List Layer Versions.

Follow new layer versions. Watch Layer Versions starts the scenario when a new version of a layer appears, and Get a Layer Version pulls its information so the people who depend on that layer hear about it.

Make does not replace your deployment tools here: the modules watch, list, read and invoke, and anything else goes through Make an API Call with the same connection. If you are still weighing platforms, the n8n vs Make comparison lays out the criteria, and Make pricing explains what each plan allows. For a guided start, see Make training.

Connect

How do you connect Amazon Lambda to Make?

  1. 01

    Create an access key in AWS

    Log in to your account, click your account name, then My Security Credentials and Access keys. Click Create New Access Key, then Show Access Key, and copy both the Access Key ID and the Secret Access Key somewhere safe.

  2. 02

    Open the connection dialog in Make

    Add any Amazon Lambda module and click Create a connection. A connection is your AWS account linked to Make once, then reused by every Amazon Lambda module. Give it a clear name in Connection name.

  3. 03

    Paste the keys and pick the region

    Paste the two keys into AWS Key and AWS Secret Key, choose your region in Region, then click Continue. Make can now read the functions and layers of that region.

First scenario

Your first scenario with Amazon Lambda

GoalWhen a function is updated in Amazon Lambda, Make invokes it once so the new code runs at the next check.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the big + to add the first module. Search for Amazon Lambda and pick Watch Functions.

  2. 02

    Link your AWS account

    Click Create a connection and fill in the keys and region from the section above. Once the connection exists, Make lists what it can read in your account, so you pick instead of typing.

  3. 03

    Add the invoke step

    Click the + on the right of Watch Functions and add Invoke a Function. Map the function coming from the trigger, so the scenario always invokes the one that was just updated.

  4. 04

    Test with Run once

    Click Run once. Make executes the scenario one time and shows the bundles each module received, so you can check which function was caught and what the invoke step returned.

  5. 05

    Schedule and switch it on

    Open the clock on the first module. A new scenario checks every 15 minutes by default, and the Free plan cannot go below that. Set the schedule, then switch the scenario on.

Triggers

What can start an Amazon Lambda scenario?

2 modules start a scenario when something happens in Amazon Lambda. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Amazon Lambda as soon as it happens.

Amazon Lambda1Watch Functions

Watch Functions

Scheduled trigger

In Make“Triggers when a function is last updated.”

Watch Functions starts your scenario whenever a function in the connected account has been updated, and hands the scenario that function so later modules can act on it. It is the natural entry point for anything that should follow a code change.

How it fires
scheduled. Make checks the app on the scenario's schedule, so an update is picked up at the next check, not the second it happens.
When to use it
a developer pushes new code and the ops lead wants the function invoked or the change logged in a shared sheet.
Watch out
each check that finds updates costs operations, one per module per bundle, so a busy account with many functions adds up faster than you might expect.
Amazon Lambda2Watch Layer Versions

Watch Layer Versions

Scheduled trigger

In Make“Triggers when a new version of an AWS Lambda layer is created.”

With Watch Layer Versions, a new version of a layer becomes the start of a scenario. A layer holds code or libraries that several functions share, so a fresh version is often news for more than one team.

How it fires
scheduled. Make polls the account at the rhythm set on the first module, so there is a delay between the new version and the run.
When to use it
a platform team publishes a shared library and wants every function owner told about the new version.
Watch out
it reacts to new versions only. To follow updates to the functions themselves, use Watch Functions in a separate scenario.
Modules

What can Make do in Amazon Lambda?

Amazon Lambda gives you 7 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Amazon Lambda1

Get a Function

Action

In Make“Gets the information of an AWS Lambda function.”

Get a Function gives you the details of one function you name, ready to map into the next module, for example a sheet row or a message to the team.

When to use it
a trigger or a list hands you a function and you need its full information before deciding what to do next.
Watch out
it reads one function per bundle, so after List Functions it runs once per function and each run counts as an operation.
Amazon Lambda2

Get a Layer Version

Action

In Make“Gets the information of a version of an AWS Lambda layer.”

This module pulls the information of one specific version of a layer, so a scenario can describe exactly which version it is talking about instead of a vague layer name.

When to use it
right after Watch Layer Versions, to enrich the alert sent to the people who rely on that shared code.
Watch out
it needs both the layer and the version; map them from the trigger rather than typing a version that will soon be outdated.
Amazon Lambda3

Invoke a Function

Action

In Make“Invokes a AWS Lambda function synchronously or asynchronously.”

Invoke a Function runs one of your Lambda functions from inside a scenario, which turns any event Make can see into a reason to execute your own code.

When to use it
a form entry, a new record or an updated function should start processing that lives in Lambda rather than in Make.
Watch out
it can call the function synchronously or asynchronously; pick synchronous only when the next module needs what the function sends back.
Amazon Lambda4

Make an API Call

Action

In Make“Performs an arbitrary authorized API call.”

When none of the listed modules covers your need, Make an API Call reaches any endpoint of the Lambda API with the connection you already set up, so there are no extra keys to manage.

When to use it
you need an operation the other 8 modules do not offer, and you know which endpoint handles it.
Watch out
this module expects you to read the AWS API reference yourself, since Make does not build the request for you here.
Amazon Lambda5

List Functions

Search

In Make“Retrieves a list of all AWS Lambda functions.”

List Functions returns every function of the account, one bundle per function, which is the simplest way to build an inventory or loop over all your code.

When to use it
an ops manager wants a sheet that shows every function without giving the whole team AWS access.
Watch out
each function becomes its own bundle, and every module placed after it runs once per bundle, so operations grow with the size of the account.
Amazon Lambda6

List Layers

Search

In Make“Retireves a list of all AWS Lambda layers.”

Use List Layers to see all the layers of the account at once, each arriving as a separate bundle you can filter, store or pass along to the next module.

When to use it
a platform team audits which shared libraries exist before cleaning up or documenting them.
Watch out
it gives layers, not their versions; chain List Layer Versions when the version history matters for your audit.
Amazon Lambda7

List Layer Versions

Search

In Make“Retrieves a list of the versions of an AWS Lambda layer.”

For one layer, List Layer Versions brings back its versions as separate bundles, so you can see how a shared library has evolved and which versions still exist.

When to use it
after List Layers, to document the history of each layer, or before deciding which old version to retire.
Watch out
it works on a single layer per run, so map the layer from the previous module instead of typing its name by hand.
Need help

Need help automating Amazon Lambda with Make?

A person reads every message.

FAQ

Amazon Lambda and Make: common questions

01Is the Amazon Lambda Make integration free?
Yes, Amazon Lambda is a standard app, available from the Free plan of Make. The Free plan allows 2 active scenarios, a minimum of 15 minutes between two scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) bring the interval down to 1 minute and remove the cap on active scenarios. Usage is counted in operations: one execution of one module on one bundle, which is what Make counts against your plan.
02What do you need to connect Amazon Lambda to Make?
You need an AWS access key: an Access Key ID and a Secret Access Key, created from the security credentials page of your AWS account. In Make, you open Create a connection, give it a name, paste the two keys into AWS Key and AWS Secret Key, then choose your region. The documentation also describes an IAM policy for Lambda that grants the permissions the modules require, which matters when the user behind the keys has limited rights.
03Do the Amazon Lambda triggers in Make fire in real time?
No. Both triggers, Watch Functions and Watch Layer Versions, are scheduled: Make checks your account on the scenario's schedule instead of being called by AWS. A new scenario checks every 15 minutes by default, which is also the minimum on the Free plan, while paid plans can go down to 1 minute. The integration has no instant trigger, so expect a short delay between the change in Lambda and the scenario run.
04What if an Amazon Lambda module is missing in Make?
Use Make an API Call. It reaches any endpoint of the Lambda API with the same connection, so you can cover an operation the 9 listed modules do not offer without new keys. You will need the AWS API reference to know which endpoint and parameters to send. If a call fails because of rights, check the IAM policy attached to the user behind your access key before changing the scenario.
05Make or n8n for Amazon Lambda?
It depends on how you prefer to work. On Make, Amazon Lambda comes with 9 ready modules, two scheduled triggers and an API call module, all behind one connection, inside a visual editor where you test with Run once. n8n may offer a node for the same app too, so compare the operations each tool exposes for your case. Pick the platform your team already knows, and check that the modules you need exist there.
Same platform

Other docs you might need on this stack.

Browse all integrations