Make.com security: where scenario data persists, and who can replay it
A Make scenario can keep copies of what passes through it: in a webhook queue and log, in run history, in incomplete executions and in data stores.
This guide maps where Make's own documentation says each copy lives, which team roles can read, replay or edit it, and the settings that change that, with a review sheet for your own account.
In this guide
Make scenario review sheet
A review sheet for one Make scenario at a time. Part A is a worked example for an invented enquiry scenario: it traces an invented payload to each place Make's documentation says it is stored and lists which roles can read, replay or edit it.
How to use itHide the instructions
Part B is the blank sheet. Every step reads a screen and records names, never secrets; nothing is run, replayed or sent. Locations and plan conditions are as Make's help pages stated them on 14 November 2026.
make.txt
Introduction9 lines
Part A. Worked example100 lines
Part B. Blank sheet70 lines
Whole template186 lines
MAKE SCENARIO REVIEW SHEET One sheet per scenario. Read-only: no step changes a setting, runs or replays a scenario, retries an incomplete execution or sends a request to a webhook. RULES FOR FILLING IT IN 1. Never write a webhook address, API key, token, password or connection credential on this sheet. Write the name of the webhook, connection, key or variable, what it can reach and who can see it. 2. Where a step says "open one entry", record which parts or fields are shown, never their values. 3. Work as an organisation Owner or Admin if you can. Make's organisations page says both roles have implicit Team Admin access in all standard teams. If you hold a narrower role, list the screens you could not open. 4. Plan conditions are as Make's own pages state them. Where a feature is not on your plan, write "not on plan". 5. Where a screen offers Edit, Retry, Replay, Run once or Delete, look and close it. Do not save or click through. ================================================== PART A. WORKED EXAMPLE Everything in Part A is invented: the business, the people, the scenario and the enquiry. Nothing was sent to Make to produce it. Each "where the enquiry persists" line says what Make's documentation says that feature stores. Organisation: Example Joinery (invented). Region: EU Team: Enquiries Scenario: Website quote request to CRM Modules, in order: Webhooks > Custom webhook "Quote form"; Data store > Add/Replace a Record in "Recent enquiries"; CRM > Create a contact (connection "CRM office login"). Error route from the CRM module: Slack > Create a message (connection "Slack sales lead"), ending in a Retry error handler. Reviewed by: the office manager (organisation Admin), 14 November 2026 Invented enquiry traced through the sheet: name Test Enquirer One email enquiry-test-01@example.com suburb Sale message Quote for a spotted gum benchtop A1. ORGANISATION AND SIGN-IN Where to look: Org, then Org Users (Make's organisations page; Make's teams page calls the tab Users outside the plan after Teams); the SSO tab (Make's single sign-on page); the 2FA Status column on Org Users (Make's two-factor enforcement page). SSO and 2FA enforcement are on the plan after Teams. Record: region | Owners and Admins | SSO on or off, and which teams new SSO users join | 2FA enforcement on or off, and who signs in through Google or SSO instead Example: EU | 1 Owner (the business owner), 1 Admin (the office manager) | SSO: not on plan | 2FA enforcement: not on plan, so each person's own 2FA is unknown Finding: two people hold implicit Team Admin access to every standard team, this one included. A2. CONNECTIONS Where to look: Credentials, then Connections. The scenarios icon lists the scenarios using each connection, the permissions icon shows what it was granted, and the filter switches between All connections and My connections (Make's connection guide). Record per connection: app | connection name | whose account it signs in as | permissions shown | scenarios using it | who can use and manage it Example: CRM | "CRM office login" | a shared office account | create and update contacts | 2 scenarios | every user in Enquiries Slack | "Slack sales lead" | the sales lead's personal Slack account | post messages | 1 scenario | every user in Enquiries Finding: a personal Slack account is usable by the whole team. Make's connection guide says all users in a team can use and manage any connection created in it, and on the Teams plan or higher suggests a separate team, with you as the only member, for personal accounts. A3. CUSTOM WEBHOOKS Where to look: Webhooks in the left sidebar, then the webhook, then its Queue and Logs tabs (Make's webhooks page); the webhook's settings from its three-dot menu (Make's Webhooks app page). Record per webhook: name, never the address | API Key authentication: number of keys | IP restrictions: set or empty | data structure: none, made by calling the webhook, or chosen in advance | Get request headers: yes or no | JSON pass-through: yes or no | items waiting in the queue | open one log entry: parts shown | who can edit it Example: "Quote form" | 0 keys | empty, so requests from all IPs are allowed | made by calling the webhook, so Make's page says incoming data is not validated | no | no | 0 | request timestamp, URL, method, headers, query and body, the response, and the parsed items | the Owner and Admin (implicit Team Admin) and 2 Team Members. The Webhooks app page lists Team Admin, Team Member and Team Restricted Member as the roles that can edit a webhook. Where the enquiry persists: in the webhook queue until the scenario processes it, whatever the confidentiality setting, after which Make's webhooks page says it is permanently deleted; and in the webhook log, request body included, for 3 days on this plan (30 days on the plan after Teams). A4. EXECUTION HISTORY Where to look: the scenario's History tab, then Details on one run (Make's scenario history page); the gear icon in the Scenario Builder for Keep data confidential (Make's scenario settings page). Record: Keep data confidential on or off, and the reason | days of history on your plan (Make's history page refers to its pricing page) | "Fulltext search" shown or not (Pro and higher plans) | one run's Details: modules whose output bundles are shown, and which fields | roles that can read execution logs Example: off, "needed for troubleshooting" | per plan | shown | output bundles for the webhook, data store, CRM and Slack modules, each with name, email, suburb and message | Owner, Admin, 2 Team Members, and the bookkeeper as Team Monitoring (Make's teams page gives that role read-only access to scenarios and execution logs) Where the enquiry persists: in the run's execution log for the plan's history period. A "Fulltext search" for enquiry-test-01 would find the run. A5. REPLAY Where to look: the replay icon next to Details in the History tab, and Run with existing data beside Run once in the Scenario Builder (Make's run replay page; all plans). Look; do not click. Record: roles that can edit and run the scenario | the oldest run still in the history | replays already in the history, and who ran them Example: Owner, Admin, 2 Team Members | per plan | none seen Where the enquiry persists: Make's run replay page says each run's trigger output data and scenario inputs are among what is stored for replay, and that a run can be replayed while it is in the history. A replay runs the current version of the scenario, so if a Team Member adds a module that sends to a new app, replaying last week's runs sends this enquiry there too. The bookkeeper cannot operate scenarios, per Make's teams page. A6. INCOMPLETE EXECUTIONS Where to look: Store incomplete executions and Discard data if storage is full under the gear icon (Make's scenario settings page); the scenario's Incomplete executions tab, beside the Diagram tab (Make's page on managing incomplete executions). Record: Store incomplete executions on or off (off by default, per Make's incomplete executions page) | Discard data if storage is full on or off | number unresolved and the oldest Created date | error types | who can retry, resolve or delete them Example: on | off | 3 unresolved, oldest created 2 October 2026 | DataError, all from the CRM module | Owner, Admin, 2 Team Members Where the enquiry persists: if the CRM module fails, in an incomplete execution whose Size covers its blueprint and the data the module was processing. Make deletes a resolved one after 30 days; the unresolved ones here are six weeks old. A RateLimitError, ConnectionError or ModuleTimeoutError is retried automatically. Make's automatic retry page says other error types are not retried automatically by default and usually need someone to resolve them. Make's page on managing incomplete executions gives the steps: fix the module, save it and click Run once, which runs it again with its original input. A7. ERROR HANDLERS Where to look: dotted connections in the Scenario Builder are error handling routes (Make's error handling overview). Record per route: module it starts from | modules on the route and the fields each maps | handler at the end (Skip, Retry, Resume, Commit, Rollback or none) | whether the first module has a Retry handler Example: CRM > Create a contact | Slack > Create a message to the #sales channel, mapping name, email, suburb and message | Retry | the webhook module has none, so Make's overview says an error there stores no incomplete execution Where the enquiry persists: every enquiry that fails at the CRM module is also copied into the #sales channel, where Slack's settings apply, not Make's. A8. DATA STORES Where to look: Data stores in the left sidebar; the scenarios icon lists the scenarios using each store (Make's data stores page). Open the records to see the fields; do not edit. Record per store: name | data structure, and Strict on or off | fields holding personal data | the key | scenarios that write and read it | what deletes records, if anything | roles that can view and edit records Example: "Recent enquiries" | structure "Enquiry", Strict off | name, email, suburb, message | the email address | written here, read by "Weekly follow-up" | nothing: no scenario uses Delete a Record or Delete All Records | Owner, Admin, 2 Team Members; Team Monitoring to be checked under User roles Where the enquiry persists: as a record keyed by its email address until someone deletes it. Make's data stores page says deleted records cannot be rolled back. A9. VARIABLES, KEYS AND SHARED COPIES Where to look: variables on the team and organisation dashboards (Make's custom variables page; Pro and Teams plans and the plan after Teams); Credentials, then Keys (Make's keys page); the blue Shared label beside the scenario name (Make's scenario sharing page). Record: variables whose names suggest a secret, by name only | keys, by name, and the modules using them | modules with a credential typed into a settings field, by module and field name only | Shared label: yes or no | blueprint exports anyone remembers Example: team variable "crmRegion", not a secret | no keys | none in this scenario; the "Weekly follow-up" scenario has an HTTP module with an Authorization header typed into its settings: finding, raised separately | not shared | one export in July, by the agency developer Finding: Make's blueprint page says a blueprint includes module settings and mapped values. On that reading, the July export carries whatever was typed into those settings at the time. A10. PEOPLE AND ROLES Where to look: Org, then Org Users (or Users, as in A1), for each person's roles; Org > User roles for each role's complete permission set (Make's organisations page). Record per person: who | organisation role | team role | reads execution logs | edits and runs the scenario | edits webhooks | reads team variables | still needs this access Example: business owner | Owner | implicit Team Admin | yes | yes | yes | yes | yes office manager | Admin | implicit Team Admin | yes | yes | yes | yes | yes sales lead | Member | Team Member | yes | yes | yes | yes | yes agency developer, contract ended in June | Member | Team Member | yes | yes | yes | yes | no: finding bookkeeper | Member | Team Monitoring | yes, read-only | no | no | no | yes, but reads every enquiry Where the answers come from: Make's teams page (role summaries), Webhooks app page (who edits webhooks) and custom variables page (who reads team variables). Confirm anything else under User roles. A11. SUMMARY: WHERE THE ENQUIRY PERSISTS, AND WHO CAN SEND IT ON Place | how long, per Make's pages | who can read it | who can send it on again Webhook queue | until processed, then permanently deleted | team members whose role reaches Webhooks | not applicable Webhook log | 3 days on this plan | team members whose role reaches Webhooks | nobody, from the log Execution log | the plan's history period | Owner, Admin, 2 Team Members, bookkeeper | Owner, Admin, 2 Team Members, by editing and replaying Replay data | while the run is in the history | as for the execution log | Owner, Admin, 2 Team Members Incomplete execution | resolved ones deleted after 30 days; the unresolved ones here are six weeks old | Owner, Admin, 2 Team Members | the same people, by retrying or by editing and running once; three error types retry automatically Data store record | until deleted; nothing here deletes it | Owner, Admin, 2 Team Members | anyone who can edit a scenario that reads the store Slack #sales | Slack's settings | channel members | outside Make CRM contact | the CRM's settings | CRM users | outside Make Decisions for the owner (this sheet's suggestions, not Make's): - Remove the agency developer from the team. - Move the Slack connection to a shared account, or into a team with one member. - Decide whether the bookkeeper needs Team Monitoring on this team. - Add a data structure, API keys or IP restrictions to "Quote form" where the website form can support them. - Resolve or delete the three unresolved incomplete executions, and name who checks the tab. - Decide how long "Recent enquiries" keeps a record, and whether it needs the email address as its key. - Map only the fields the #sales channel needs on the error route. ================================================== PART B. BLANK SHEET Organisation: ______________ Region: ______ Team: ______________ Scenario: ______________ Modules, in order: ________________________________ Reviewed by, and role: ______________ Date: ______________ Screens I could not open: ______________ B1. ORGANISATION AND SIGN-IN Region: ______ Owners: ______ Admins: ______ SSO: on / off / not on plan. Teams new SSO users join: ______ 2FA enforcement: on / off / not on plan. People signing in through Google or SSO: ______ B2. CONNECTIONS (one line each) App | connection name | whose account | permissions shown | scenarios using it | who can use and manage it 1. ______________________________ 2. ______________________________ 3. ______________________________ B3. CUSTOM WEBHOOKS (one line each, never the address) Name | API keys (count) | IP restrictions (set / empty) | data structure (none / by calling / chosen) | Get request headers | JSON pass-through | queue items | log entry shows | who can edit 1. ______________________________ B4. EXECUTION HISTORY Keep data confidential: on / off. Reason: ______ History period on our plan: ______ Fulltext search shown: yes / no One run's Details show these modules and fields: ______ Roles that can read execution logs: ______ B5. REPLAY Roles that can edit and run this scenario: ______ Oldest run still in the history: ______ Replays already in the history (who, when): ______ B6. INCOMPLETE EXECUTIONS Store incomplete executions: on / off Discard data if storage is full: on / off Unresolved: ______ Oldest Created date: ______ Error types: ______ Who can retry, resolve or delete: ______ Person who checks the tab: ______ B7. ERROR HANDLERS (one line per route) Starts from | modules on the route and fields mapped | handler | where the fields end up 1. ______________________________ First module has a Retry handler: yes / no B8. DATA STORES (one line each) Name | structure, Strict | personal data fields | key | scenarios writing and reading | what deletes records | roles that can view and edit 1. ______________________________ B9. VARIABLES, KEYS AND SHARED COPIES (names only) Variables that look like secrets: ______ Keys, and the modules using them: ______ Modules with a credential typed into a settings field (module and field): ______ Shared label: yes / no Known blueprint exports: ______ B10. PEOPLE AND ROLES (one line per person) Who | org role | team role | reads execution logs | edits and runs the scenario | edits webhooks | reads team variables | still needs access 1. ______________________________ 2. ______________________________ B11. SUMMARY Place | how long | who can read it | who can send it on again Webhook queue | ______ | ______ | ______ Webhook log | ______ | ______ | ______ Execution log | ______ | ______ | ______ Replay data | ______ | ______ | ______ Incomplete executions | ______ | ______ | ______ Data store records | ______ | ______ | ______ Apps on error routes | ______ | ______ | ______ Apps the scenario writes to | ______ | ______ | ______ Decisions, and who owns each: ______ Next review date: ______
What Make is, and how a scenario reaches your data
In Make, an automation is a scenario.
Make's blueprint page says a blueprint, a reusable version of a scenario, includes the scenario's modules, their settings and the mapped values. Make's organisations page says each organisation chooses the data centre location where its data is stored and processed, from the locations the page lists as the United States and the European Union, and that the location cannot be changed after the organisation is created.
A run starts from a trigger.
Make's webhooks page describes webhooks, which create a URL that an external app, a service or another scenario can call over HTTPS, and polling triggers, which periodically ask a service for new data.
To act in other services, a scenario uses connections. Make's connection guide says that for some apps you log in to the service and grant Make permission to access your profile and data, while other apps may require credentials such as a username and password, an API key, or a client ID and client secret.
Take one example set-up. A quote form on a business website posts each enquiry to a Make webhook. The scenario saves the enquiry in a Make data store, creates a contact in the CRM through one connection, and posts a summary to a chat channel through another.
In that position Make sits in the middle of the customer's data: it receives the enquiry, holds access to every app downstream and, as the following sections show from Make's own pages, can keep copies of the enquiry in several places after the run has finished.
That gives a Make account two halves. One is how Make runs its platform, which this guide does not assess and makes no claims about. The other is how your organisation is set up inside it: who belongs to which team, whose accounts the connections use, which settings keep or discard run data, and where a failed record goes.
The second half is on screens you can read in your own account, and it is what the scenario review sheet on this page records.
Several features below depend on the plan. Make's custom variables page names three plans, Pro, Teams and a third it lists after Teams. This guide calls that third one the plan after Teams.
What Make's documentation says it does, and what stays with you
Make's help pages describe some behaviour as the platform's own.
It is worth knowing because it marks where Make's part of the arrangement ends:
- A webhook that has not been connected to any scenario for more than 5 days (120 hours) is deactivated automatically and answers 410 Gone, according to Make's webhooks page.
- The same page says Make can process up to 300 incoming webhook requests per 10 second interval and returns status 429 for anything beyond that.
- Make's Webhooks app page says a webhook API key cannot be viewed after it is created, and that the x-make-apikey header is sanitised automatically, so a scenario does not receive its value.
- Make's connection guide says editing a connection replaces the original data, and that the full set of credentials has to be entered again because Make does not keep the original connection data.
- The data centre location chosen for an organisation cannot be changed after the organisation is created, according to Make's organisations page.
What someone in your organisation chose
Everything else in this guide is configuration that someone in your organisation chose, or left as it was when the scenario was built:
- Team membership and roles, which decide who reaches a team's scenarios, connections, webhooks, keys and data stores.
- Whose accounts the connections sign in with, given that Make's connection guide says every user in a team can use and manage any connection created in it.
- Which checks a custom webhook applies to its callers. API keys, IP restrictions and a data structure are each optional in Make's Webhooks app.
- Whether a scenario keeps run data, through its Keep data confidential and Store incomplete executions settings.
- Where a failed record goes, since an error handling route can hold ordinary modules, such as one that posts a message to Slack.
- What sits in custom variables, data stores and module settings, which other people in the team can read, depending on their roles.
Where a payload persists inside Make
One request to a webhook can leave copies in several places, each with its own lifetime and its own readers.
Make documents them on separate pages. This section follows an enquiry through them in the order it meets them, and the review sheet keeps the same order.
Make's webhooks page says that when a webhook receives a request, the request is stored in that webhook's own queue, and that incoming webhook data is always stored there regardless of the scenario's confidentiality setting. Once a queue is full, the page says, Make rejects incoming data over the limit.
As soon as a scenario has processed the data, the page says, it is permanently deleted. On a scheduled webhook, requests accumulate in the queue until the schedule criteria are met.
The webhook log is a second copy with a fixed lifetime. The same page says Make keeps webhook logs for 3 days, or 30 days for organisations on the plan after Teams, and that each log's detail shows the request's timestamp, URL, method, headers, query and body, the response, and the parsed items.
Whether a scenario's confidentiality setting changes what that log shows is something to read off your own account: the review sheet asks you to open one log entry and record which parts it displays.
Make's scenario settings page says Make stores the data processed during each run in the execution logs, so that runs can be inspected and troubleshot. Make's scenario history page says the Details of a run in the scenario's History tab show full information about the run, including the bundles processed, and let you check the output bundles of a specific module.
On Pro and higher plans, the history page describes a "Fulltext search" for any term in module outputs across the execution history, and its example searches for a participant's name.
How many days of history are kept depends on the pricing plan, and the history page refers readers to Make's pricing page for the figure.
Keep data confidential changes what is kept. With it on, the scenario settings page says Make does not retain the run data, the logs still show that a run happened but without the payload, and there are very limited options to solve errors. Make recommends it for scenarios that handle sensitive or personal data that should not be stored after processing.
It trades evidence for exposure, and this guide's view is that the business that owns the data should make that choice per scenario and write it down, rather than inherit whatever the builder picked.
Make's scenario run replay page says replay is available on all plans and runs the current version of a scenario with the trigger data of an earlier run. To support it, the page says Make stores the trigger output data, the scenario inputs and the most up-to-date variable value, and a run stays replayable for as long as it is in the scenario history.
During a replay the data passes through every module again, including modules that succeeded the first time. The page's own example adds an Airtable module to a scenario and replays a past week's run to backfill Airtable.
Where a run cannot be replayed, the page gives the likely reason as a run type that is not stored: a check run that returned no new data, or a single module run.
Replay is a useful recovery tool. It is also the plainest answer to the question of who can resend old data. In this guide's reading, anyone who can edit a scenario and run it can send last week's enquiries to a destination that did not exist last week, and Make's page says replayed runs appear in the scenario history like standard runs.
Make's incomplete executions page says they are disabled by default and switched on per scenario with Store incomplete executions. When they are on and a run fails, Make keeps the unfinished run in the scenario's Incomplete executions tab. Make's page on managing them says the tab's Size column covers the incomplete execution's blueprint and the data the failing module was processing. The record that failed therefore waits there.
The pages give these lifetimes and limits. A resolved incomplete execution is deleted automatically after 30 days, and one deleted from the tab cannot be put back. Make's automatic retry page says incomplete executions caused by RateLimitError, ConnectionError or ModuleTimeoutError are retried on a schedule, with the last attempt 7 hours 51 minutes after the original run, and that one whose attempts all fail is marked Unresolved.
The scenario settings page says the stored data counts towards the plan's storage limits, and that with Discard data if storage is full turned on, failed data that does not fit is discarded and cannot be recovered.
Resolving one yourself, rather than retrying it, is an edit followed by a run. The management page's steps are to fix the module that caused the error, save it and click Run once, after which the incomplete execution runs again from that module with its original input. As with replay, whoever can edit the scenario decides where that stored input goes next.
Data stores are where a payload is kept on purpose. Make's data stores page describes them as similar to a simple database, used to store data from a scenario or to pass data between scenarios and between runs.
Records are viewed, added, edited and deleted from the Data stores area in the left sidebar, or written and removed by the data store modules, which include Delete a Record and Delete All Records. The page says deleted records cannot be rolled back and that there is no automated process to restore lost values; its method is to find the runs that inserted the records in the execution history and copy the data back.
Two settings shape what a store accepts. Without a data structure, the page says the store contains only the primary key; with one, a Strict option, when enabled, rejects a payload carrying items the structure does not specify. The review questions for each store are this guide's own: which fields hold personal data, which scenarios write and read them, and what, if anything, ever deletes them.
Some places hold values rather than payloads, and each is a place a secret could end up. Custom variables, which Make's page says are available only on its Pro and Teams plans and the plan after Teams, are not meant to store secrets in Make's own words.
The same page says their values are stored in plain text without encryption, and that other team members and organisation admins can access all custom variables.
Values typed into a module's settings travel with the scenario. Make's blueprint page says a blueprint includes modules, module settings and mapped values, and can be shared with users inside or outside the organisation, while connections have to be created again after import. Its scenario sharing page says a scenario shared through a public link includes module settings with mapped values but not the API keys, passwords and other details used to create a connection, and that anyone who copied the scenario while the page was public keeps that copy after sharing is switched off.
Keys are held separately: Make's keys page says a key created from a module's Key field is saved in the Keys section under Credentials, and that the HTTP app saves API key and Basic Auth credentials as a keychain.
This guide's reading of those pages is that a token pasted into a free-text field of a module, such as a header value, rather than held in a connection or a keychain, is part of the module's settings and goes wherever the blueprint goes. If a review turns one up, treat it as exposed; the secrets exposure guide in this library covers what to do first.
Who can see, replay or edit it: teams and roles
Make's access model has two levels.
Its teams page says members of a team have access only to the scenarios and data that belong to their team, and lists those items: scenarios, templates, connections, webhooks, keys, devices, data stores, data structures, custom functions and credential requests. Each belongs to exactly one team and cannot be moved to another.
Above the teams sit organisation roles, and Make's organisations page says the Owner and Admin roles include access to all standard teams, which gives them implicit Team Admin access there.
Team structure depends on the plan. The teams page says that on a plan lower than Teams, an organisation can have only one team and cannot manage roles within it. Custom roles, built from a list of permissions, are limited by Make's custom roles page to the plan after Teams.
That page also says team permissions are all-or-nothing per resource type, so a role that may manage scenarios may manage every scenario in the team, and it points to a separate team as the way to limit access to specific resources.
The default team roles, as Make's teams page summarises them:
- Team Admin: full access to team resources and settings, including member management and audit logs.
- Team Member: full access to team-owned resources, but no management of members, team settings or the team audit logs.
- Team Operator: read-only access to general team resources, and can activate, deactivate and schedule scenarios.
- Team Monitoring: read-only access to selected team information, including scenarios and execution logs, and cannot edit resources or operate scenarios.
- Team Restricted Member: a deprecated legacy role with broad editing access, which the page says not to use for new assignments.
- Team Guest: access only to credential requests addressed to that user.
What the roles mean for payloads
Two conclusions follow, and both are this guide's reading rather than Make's words. Execution logs hold run data unless a scenario keeps data confidential, so Team Monitoring, which changes nothing, still reads payloads. And because a replay runs the current version of a scenario on stored trigger data, and resolving an incomplete execution means editing the failing module and running it again on its original input, every role that can edit and run a scenario can choose where stored input goes next.
Make's pages add two specifics. The Webhooks app page says webhook settings can be edited by Team Admin, Team Member and Team Restricted Member. The custom variables page gives a permission table in which Team Admin, Team Member, Team Operator and Team Restricted Member can read team variables and Team Monitoring cannot. For the complete permission set of any role, Make's organisations page points to Org > User roles.
Connections are shared by the team
Make's connection guide says every user in a team can use and manage any connection created in that team, and warns to use personal third-party accounts and credentials carefully, especially when the team has other users. On the Teams plan or higher, it suggests a separate team in which you are the only member for connections made with your personal accounts.
Under Credentials, then Connections, the guide says each connection shows the scenarios that use it and the permissions it was granted, and a filter separates your own connections from everyone's.
Private spaces and sign-in
Make's private spaces page says private spaces are available on all plans and, once an admin enables them, give every member except guests their own workspace for scenarios and connections they do not want teammates to access. On the plan after Teams, the organisation owner can turn on Admin visibility, which lets admins open a member's private space read-only and see scenario names, modules used and credit usage, but not module settings, run history, run details, data stores or connections.
Sign-in controls depend on the plan too. Make's single sign-on page says SSO is available to customers on the plan after Teams and supports OIDC and SAML 2, and its set-up steps include choosing which teams a new user signing in through SSO joins. The two-factor enforcement page gives the same plan condition and says enforcement covers only users who sign in with Make's own email and password; for anyone signing in through Google or an identity provider, two-factor authentication has to be configured and enforced within that provider.
Settings worth reading in each scenario
Each line gives what Make's page says, then this guide's suggestion, which is yours to weigh against how the scenario is used.
- Keep data confidential. Make's scenario settings page says that with it off, run data is stored in the execution logs, and with it on, the logs show a run happened without the payload. Suggestion: record the setting and the reason for every scenario that carries personal data.
- Store incomplete executions. Disabled by default, according to Make's incomplete executions page. Suggestion: where it is on for a scenario that carries personal data, name a person who clears the Incomplete executions tab, and record the oldest unresolved date at each review.
- Discard data if storage is full. The scenario settings page says that with a full incomplete executions folder, Make discards the failed data and keeps the scenario running, and that discarded data cannot be recovered. Make's error handling overview describes an enable data loss setting, and says that with data loss disabled and that storage full, Make disables the scenario. Suggestion: record which way your scenario settings show it, so that the choice between losing a record and stopping the scenario is one someone made.
- Custom webhook checks. Among a custom webhook's settings, Make's Webhooks app page describes three optional checks: API keys sent in the x-make-apikey header; IP restrictions, which when left empty allow requests from all IPs; and a data structure, without which Make accepts all incoming data without validation. With a data structure selected for the webhook, requests that fail validation are rejected with HTTP status 400, but the page says one made by calling the webhook is stored with it and not used to validate incoming data. Suggestion: record which of the three each webhook uses, and check the calling system's own documentation for whether it can send a fixed header or calls from fixed addresses.
- Get request headers. The same page says that with this set to Yes, headers from the request are extracted and made available for mapping in the scenario. Suggestion: where a caller sends its own credentials in a header, record whether any later module maps the headers onward.
- Error handling routes. Make's error handling overview says a route does not need an error handler at all; its example route holds only a Slack > Create a message module that sends a notification when an error occurs. Suggestion: list every module on every error route and the fields it maps, because a notification built from the failed bundle copies that record into another app, where Make's settings no longer apply.
- Skip and Resume handlers. The overview says Skip removes the affected bundle and marks the run as successful even if an error occurs, and Resume substitutes a predefined output and continues with a Success status. Suggestion: record which modules carry them, since those runs will not show as errors in the history.
- Errors on the first module. The overview says Make does not store an incomplete execution when the first module fails, unless a Retry error handler is attached to it, and that it disables an instantly triggered scenario immediately if an error happens. Suggestion: on webhook-triggered scenarios, record what the first module does on an error.
- Public scenario pages. Make's scenario sharing page says a blue Shared label next to the scenario name shows that the public page is on. Suggestion: record the label for every scenario, and for any that is shared, list the module settings a copy made from the link would include.
How to use the scenario review sheet
The sheet takes one scenario at a time and follows its data from the moment a request arrives to the last place a copy is kept.
Part A is a worked example for an invented business and an invented enquiry. Part B is the same sheet blank. Every step reads a screen. None changes a setting, runs a scenario, replays a run, retries an incomplete execution or sends a request to a webhook.
Three rules keep the sheet itself from becoming a leak. Never copy a webhook address, API key, token, password or connection credential onto it: write the name of the webhook or connection, what it can reach and who can see it.
Where a step asks you to open a log or a record, write down which fields appear, not their values. And keep the finished sheet where you keep the scenario's own documentation, because it describes where your customers' data sits.
Work through it as someone who can see the whole team, such as an organisation Owner or Admin, so that what you record is complete. If you hold a narrower role, note which screens you could not open; that gap is a finding about who can see what. Where a row depends on a feature your plan does not include, such as single sign-on or custom variables, write "not on plan" and move on.
Each row names the Make page that says where to look, so you can check the location yourself if a screen has moved.
The summary at the end of Part A is the part to show the business owner. It lists each place the enquiry persists, how long Make's pages say it stays there, who can read it, and who can send it on again, followed by the decisions the review leaves with the owner.
Limits of the scenario review sheet
The sheet is a snapshot of configuration on the date written at its top.
It has edges, and they are worth stating before anyone treats a tidy sheet as a clean bill of health.
- How Make runs its platform. The sheet reads your settings and says nothing about Make's own infrastructure or operations, which are matters for Make's published material and your agreement with Make.
- What already left Make. An enquiry the scenario sent to a CRM, a spreadsheet or a chat channel is governed by that app's settings. The sheet records where copies went, not who can see them there.
- Anything older than the retention windows. Make's history page ties how long run history is kept to the plan, and its webhooks page says webhook logs are kept for 3 days, or 30 days on the plan after Teams. A review cannot show runs or requests older than that.
- Who changed what. Make's audit logs page limits audit logs to the plan after Teams and keeps them for 12 months. It lists scenario events as created, updated, deleted, activated, deactivated, settings updated and restored, and says data store record events cover the Make interface and API, not changes made through the data store modules.
- Whether a webhook address has leaked. The sheet records which checks a webhook applies to its callers. It cannot show who else holds the address.
- How the scenario behaves when someone sends it crafted input. Reading a setting shows how it is configured, not what happens under attack. That is testing, and it belongs with the application that sends data to Make or receives it.
- Your own application's records of what it sends to Make and what Make sends back. The security logging and monitoring guide in this library covers which events an application should record.
Where Clever Ops comes in
This guide is informational and describes no Clever Ops service.
Make's platform belongs to another business, so under the Clever Ops methodology it stays outside any test's scope without Make's agreement. Whether a customer may test Make itself is a matter for Make's own terms, which this page does not summarise; read them before any testing that would touch Make.
What Clever Ops tests is the application around a scenario. A web application and API penetration test is a signed-in test of a custom application and its API, called directly rather than only through the screens.
A secure code review follows each entry point in scope that reads or writes data, webhook handlers among them, from the incoming request through to the database query. If your application has an API that a Make scenario calls, or webhook handlers that receive Make's requests, those are among the ways in that either piece of work can cover once they are in the agreed scope.
Clever Ops offers neither round-the-clock monitoring nor emergency incident response. If a scenario has sent data where it should not have, or a connection is being used by someone it should not be, call an incident response specialist first.
The report sets out what was tested and what it found. It is not a certificate, and the decision it informs, such as a customer's or an auditor's, belongs to someone else. An application that Clever Ops built or hosts gets a security review instead of an independent test, with the builder and the host named in the report.
Frequently asked questions
Unless the scenario keeps data confidential, yes. Make's scenario settings page says Make stores the data processed during each run in the execution logs so that runs can be inspected, and that with Keep data confidential on, the logs show a run happened without the payload. That setting does not cover the webhook queue: Make's webhooks page says incoming webhook data is always stored in the queue regardless of it, and deleted once a scenario has processed it. Incomplete executions and data stores keep data under their own rules.
Make's Webhooks app page describes three optional checks on a custom webhook: API keys, which callers send in the x-make-apikey header; IP restrictions, which when left empty allow requests from all IPs; and a data structure selected for the webhook, which rejects requests that fail validation with HTTP status 400. Without a data structure, the page says Make accepts all incoming data without validation, and one made by calling the webhook URL is not used to validate incoming data either. Which of the three a webhook uses can be read from its settings under Webhooks, and the review sheet on this page records it.
Make's connection guide says all users in a team can use and manage any connection created in that team, and warns to use personal third-party accounts and credentials carefully when the team has other users. On the Teams plan or higher, it suggests a separate team in which you are the only member for connections made with personal accounts. Under Credentials, then Connections, each connection shows the scenarios using it and the permissions it was granted.
A failed run is listed in the scenario history like any other run, for the number of days the plan stores history, and Make's scenario settings page says its data is stored in the execution logs unless Keep data confidential is on. It is kept as an incomplete execution only if Store incomplete executions is switched on, which Make's incomplete executions page says it is not by default. When it is, a failed run is kept in the scenario's Incomplete executions tab with the data the failing module was processing, though Make's error handling overview says an error on the first module stores no incomplete execution unless that module has a Retry error handler. Make's page on managing them says resolved ones are deleted automatically after 30 days and that a deleted one cannot be put back. Make's scenario settings page adds that the stored data counts towards the plan's storage limits, and with Discard data if storage is full on, failed data that does not fit is discarded and cannot be recovered.
Yes, as Make describes replay. Its scenario run replay page says replay, available on all plans, runs the current version of a scenario with the trigger data of an earlier run, and its own example adds an Airtable module and replays a past week's run to backfill Airtable. A run can be replayed while it is in the scenario history, and replayed runs appear in that history and consume credits. Who can edit and run a scenario therefore decides where its old trigger data can go.
Make's own pages limit both to the plan after Teams. The single sign-on page lists OIDC and SAML 2, and its set-up steps include choosing which teams new SSO users join. The two-factor enforcement page says enforcement covers only users who sign in with Make's own email and password; for people signing in through Google or an identity provider, two-factor authentication has to be configured and enforced within that provider.
Scope the right test for your application
Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.