Get AI summaries of any video or article — Sign up free
Notion Forms are a Game Changer thumbnail

Notion Forms are a Game Changer

5 min read

Based on Thomas Frank Explains's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Notion Forms can be shared publicly via a link while keeping the underlying responses database private.

Briefing

Notion Forms lets users create and share a database-backed form in minutes—then automatically routes submissions into database properties—without making the underlying database public. The workflow is fast enough to treat forms as a lightweight input layer for ideas, questions, and internal requests, while still keeping the data model and permissions inside Notion.

A public form can be created from a new page by typing “/form” in Notion. Once shared as “anyone on the web with the link,” the form opens in a browser and submissions appear under “responses.” Those responses are automatically mapped to database properties: a text answer lands in a title-like field, multiple-choice answers become select properties, and the system records the respondent as “Anonymous” when no account is involved. Notion Forms can also be embedded into public Notion Pages (including Notion Sites), so a portfolio or landing page can collect submissions directly at the bottom of the page.

The practical payoff comes from using forms as an interface to existing databases. For an “audience ideas” database, the creator builds a public “video suggestion form” that writes new pages into the database. Instead of relying only on auto-generated questions from existing properties, the form builder can create custom fields: a required “first name,” a required “type of suggestion” (video topic, question, template suggestion, or other), and an optional email field for newsletter signups. A key nuance is that the database itself can remain private while the form link is public—so the builder is publishable even when the responses live in a non-public workspace.

For internal workflows, a second form is created directly from a source database in the workspace. This internal “topic suggestion form” is shared to “anyone on the web with the link” but is intended for team members logged into the workspace. It demonstrates advanced binding: form questions can map to properties like description, and can also bind to relation properties, producing a dropdown of related pages (e.g., selecting which channel a content idea belongs to). It can even include file uploads via a files/media property, letting teammates attach an image with the submission.

Sharing the external form is made easier with short links. Since form URLs can be long and Notion doesn’t offer custom slugs for these form links, the creator uses a third-party short-link service (dub.co) and a Raycast extension to generate a branded, shareable URL.

Finally, the submissions can be turned into actionable work using Notion automations and button properties. A queue view is set up with statuses like “not reviewed,” “approved,” and “rejected.” Clicking an “approve” button updates the submission status and creates a new page in the content ideas database, using the automation formula builder to pull context from the button-triggering page (e.g., copying the submission text into the new page’s name/description and setting the new page’s status to “idea”).

The main limitations are practical: hidden fields with default values can’t be created for form submissions, and form submissions can’t be distinguished from pages created through other methods—making it harder to target automations specifically to form inputs. There’s also no current way to embed Notion Forms on external websites (like Framer or WordPress), only on Notion pages. The creator compares alternatives such as Tally, uForm, Typeform, and Google Forms, but positions Notion Forms as the simplest option when the goal is automation and database integration inside Notion.

Cornell Notes

Notion Forms provide a fast way to collect structured input and automatically store it in Notion databases. Public forms can be shared via a link and embedded on public Notion Pages, while the underlying database can remain private. Form builders can create custom questions, bind answers to database properties (including relations and file uploads), and map responses directly into database fields. With automations and button properties, submissions can move through a review queue and trigger creation of new pages in another database using context from the submission. Key gaps remain: hidden default fields aren’t supported, form submissions can’t be uniquely targeted in automations, and external website embedding isn’t available yet.

How does a public Notion Form differ from making the whole database public?

A form can be shared as “anyone on the web with the link” while the source database stays private. That means the form page and the submission endpoint are accessible publicly, but the database containing responses isn’t published to the web. In the workflow shown, the form builder is public, yet the database responses remain restricted to the workspace.

What happens to submitted answers once someone fills out a Notion Form?

Responses are automatically mapped to database properties. For example, a text answer can land in a title-like property, multiple-choice answers become select properties, and the system records the respondent as “Anonymous” when the submitter isn’t identified. A “created date” is also added to the resulting entry.

Why does creating a form from the source database matter for customization?

Creating a form from the source database enables deeper control over how questions bind to existing properties. The creator demonstrates two modes: auto-creating questions from existing properties, or starting from scratch to define custom fields. Starting from scratch allows adding fields like “type of suggestion” (single choice), required “first name,” and an optional email field for newsletter signups.

What advanced form features are demonstrated for internal team workflows?

Internal forms can bind to more complex property types. The example includes binding to a relation property to produce a dropdown of related pages (e.g., selecting a “channel”), and adding a files/media property to allow image uploads. The internal form is then submitted inside the workspace, creating new pages directly in the target database.

How does the approval queue turn form submissions into new content ideas?

A queue view uses a status property with values like “not reviewed,” “approved,” and “rejected.” Button properties (“approve” and “reject”) run automations: reject updates the status to “rejected,” while approve updates status to “approved” and creates a new page in the content ideas database. The automation formula builder pulls context from the triggering page (e.g., copying submission text and including the submitter’s first name in the new page’s description), then sets the new page’s status to “idea.”

What limitations remain with Notion Forms in their current incarnation?

Hidden fields with default values can’t be created, which prevents setting internal properties (like a submission status) invisibly at submit time. Also, form submissions can’t be differentiated from pages created via other methods, limiting database automations that should target only form inputs. Additionally, forms can’t be embedded on non-Notion websites yet, only on Notion pages.

Review Questions

  1. What mechanism allows a Notion Form to be public while the underlying responses database stays private?
  2. Describe how the approve button automation uses context to create and populate a new page in another database.
  3. Which two limitations most affect automation targeting and hidden metadata in Notion Forms?

Key Points

  1. 1

    Notion Forms can be shared publicly via a link while keeping the underlying responses database private.

  2. 2

    Form submissions automatically map to database properties, including text, select/multiple-choice fields, and respondent identity when applicable.

  3. 3

    Forms can be embedded on public Notion Pages, enabling landing pages and portfolios to collect structured submissions.

  4. 4

    Creating forms from a source database allows custom question design and binding to advanced property types like relations and files/media uploads.

  5. 5

    A review queue can be implemented with status properties and button-triggered automations to approve/reject submissions and create new pages in another database.

  6. 6

    Notion Forms currently lack hidden default fields and do not distinguish form-created pages from other page creation methods, limiting automation precision.

  7. 7

    External website embedding for Notion Forms isn’t available yet, pushing teams toward Notion-hosted pages or third-party form tools.

Highlights

A public form can feed a private database: the form link is accessible on the web, but the database itself doesn’t need to be published.
Responses aren’t just collected—they’re structured automatically into database properties, including select fields and timestamps.
Relation-bound questions turn forms into guided workflows, letting teams pick from existing database pages via dropdowns.
Button-triggered automations can move submissions through a queue and create new content-idea pages, using the formula builder to carry over submission context.
Notion Forms still miss hidden default fields and external-site embedding, which constrains advanced automation and distribution.

Topics

  • Notion Forms
  • Database-Backed Forms
  • Public vs Private Data
  • Form Automations
  • Content Idea Queue

Mentioned