Skip to content
Tutorials Center
My learning

Topics

Lesson 25 of 36 ยท Tables and Interfaces

Interfaces: Forms, Pages and Approvals

Build the human side of an automation with Zapier Interfaces: forms that start Zaps, pages that show table data, approval steps and how to keep input clean.

Automation is not only machines talking to machines. Somebody has to submit a request, approve an expense, or look at a dashboard. Zapier Interfaces is the part of Zapier for building those small web pages without code: forms that collect input, pages that show and edit table data, and (in newer releases) chat-style components. In this lesson you learn the roles each plays, how they connect to Zaps and Tables, and how to design input that automation can trust.

The product cannot run on this site. Menu names and the exact component list change as Zapier releases updates, so use this lesson for the concepts and check the current documentation for names. The code blocks are our own JavaScript stand-ins for validation and approval logic.

What Interfaces are for

Need Interface piece Typical link
Collect structured input Form Submitting starts a Zap, or writes a table record
Show a list of records Page with a table or list component Reads a Zapier Table
Let a person decide Approval style page or buttons A Zap waits, then continues on the answer
Ask in natural language Chatbot component Backed by an AI agent and your data

A very common pattern: form โ†’ Zap or table โ†’ page. A teammate submits a purchase request through the form; the record lands in a table; a manager sees it on a page and clicks Approve; a Zap triggered by the updated record notifies finance.

Forms

A form is a list of fields, each with a type (text, long text, number, date, dropdown, checkbox, file upload), a label, an optional help text and a required switch. When someone submits, two things can happen:

  1. A trigger (for example "New Form Submission" in the Interfaces app) starts a Zap with the submitted values as fields.
  2. The submission is written to a table as a record, and a "New Record" trigger starts the Zap.

Design principles that make automation reliable:

  • Constrain choices. A dropdown for "Department" produces five known values; free text produces fifty spellings. Filters and lookups depend on exact values.
  • Mark required fields that later steps need. An empty email breaks the "send email" step.
  • Ask for ids, not names, when you can: a ticket number identifies the item, a title does not.
  • Keep it short. Every extra field lowers completion rates.
  • Validate on the way in (type, format) and again in the Zap, because other channels may bypass the form.
JS Stand-in: validate a submitted form

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Pages and tables

A page shows information. Typical components are a table of records, a list, a detail view, buttons and text. Pages read from Zapier Tables, so the table is the single source of truth: automations write to it, people see it. Useful settings:

  • Filters and sorts in the page, so a manager sees only items waiting for them.
  • Edit permissions: which fields can be changed from the page and which are read-only. Make status editable and amount read-only on an approval page.
  • Buttons that update a field (set status to approved) or start a Zap with the record.

Access is controlled by who may open the page: only you, specific teammates, or anyone with the link, depending on your plan and settings. Treat any page with business data as private by default; see Security and Access Control.

Approvals: waiting for a human

An approval flow has a state machine: pending โ†’ approved or pending โ†’ rejected. It is easiest to model in a table with a status field:

stateDiagram-v2
    [*] --> pending: form submitted
    pending --> approved: manager clicks Approve
    pending --> rejected: manager clicks Reject
    approved --> paid: finance Zap runs
    rejected --> [*]
    paid --> [*]

Each arrow is a Zap or a person changing the status field.

The Zap that handles approval triggers on the updated record (or on a view such as "status is approved") and uses a filter so it only acts on the transition it cares about. Never let a Zap react to pending when it should react to approved.

For time limits, add a reminder Zap on a schedule that looks for pending records older than two days and pings the manager. Zapier also has dedicated steps for "ask for approval" in some plans; where they exist they pause a Zap and resume on the decision.

JS Stand-in: an approval state machine

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The refusal in the second call is exactly what a Zap filter should do: a rejected request must never reach the payment step.

Keeping an audit trail

When a human decision triggers money or access, record who decided and when. Add decided_by and decided_at fields filled in by the Zap that handles the change (many tools provide the user's email in the trigger data). The history list in the stand-in above is the same idea. An audit trail also helps when you debug (Error Handling and Replays).

Common mistakes

  • Free-text where a dropdown would do.
  • Editable ids or amounts on a page used for approvals.
  • No notification: a request that nobody knows about waits forever; always notify the next person.
  • One giant form for several processes: build separate forms and route them.
  • Public link to a private page.

Check your understanding

Quick check ยท 3 questions

of 3 answered You scored / 3 ยท perfect!

  1. 1. Why use a dropdown instead of free text for a Department field?

    Exact, predictable values keep automation logic simple.
  2. 2. On an approval page, which setting is wise?

    Reviewers should be able to decide but not change the numbers they are approving.
  3. 3. A Zap sends the payment when a record's status changes. Which guard is essential?

    A filter on the transition prevents payments for pending or rejected items.

Summary

  • Interfaces give automations a human side: forms for input, pages for viewing and editing table data, buttons and approvals for decisions.
  • Forms feed Zaps directly or via a table; constrain and validate input.
  • Model approvals as a status field with allowed transitions and filter on the transition you want.
  • Record who decided and when; notify the next person; keep pages private by default.

Next: Make: Scenarios, Modules and Bundles