Studio mode
Studio mode is where business-team authors — Pathmakers — design the experience the rest of the team uses. You're authoring artifacts here; the runtime executes them elsewhere. A View you build renders to data your team browses in Workspace. A Workflow you draw fires off functions in Forge's Compute runtime. A Policy you publish gates record writes at the gateway. An Auth Flow you compose runs as the sign-in screen your end users see.
If you're a developer, you'll spend most of your time in Forge; Studio is for the people in your org who need to shape what records get captured, what reports get viewed, what approvals get required, and how end users sign in — without writing infrastructure code. Studio opens on the Atelier dashboard — a Pulse surface tuned for authors: active View count, active Workflow count, pending approvals (with a warning accent when any are waiting on you), recent Workflow run failures, pending publishes attributed to you, Auth Flow activity over the last day, recently-touched saved queries.
Designing what your team uses day-to-day
The Compose cluster is where the artifacts your team consumes get authored. Four entity types compose with one another — Views are the foundation; Forms write to View-projected schemas; Workflows trigger on View record events; Dashboards aggregate View-projected data.
Views define a query against your data, with row-level-security bindings, formatting, sorting, and grouping. Views power the record tables your team browses; they also feed Forms (which write back to the View's projected schema), Workflows (which trigger on the View's record events), and Dashboards (which aggregate View data). Build them once, compose them everywhere.
Forms is drag-and-drop authoring for record capture — field composition, validation rules, conditional logic, multi-step wizards. The Forms designer is the Paperless extension's Form Builder; what you author here is what end users see when they fill in a form on the Paperless mobile app, in an embedded widget on your website, or inside a chat conversation.
Dashboards is the chart-and-KPI designer — widget composition, drill-down primitives, filter widgets. What you publish renders inside Workspace at /workspace/<workspace-slug>/dashboards/<dashboard-slug> for the Scouts pinned to that workspace.
Spaces is where you bundle the above into workspaces — named bundles of Views, Forms, and Dashboards with an audience scope (individual users, user groups, or role overlays). Pathmakers create workspaces, configure who can see them, and pin entities into a 2-3-level hierarchy. Workspace creation composes with Maker-Checker — if your project has approvals attached, your changes wait for sign-off before Scouts see them.
Automating work
Workflows is a visual workflow designer — triggers (record events, schedules, HTTP calls, form submissions), actions (function invocations, record writes, notifications, extension calls), and conditional branching between them. Workflows orchestrate per-record and per-event automation. They're how a Paperless submission turns into a Salesforce opportunity, or how a customer-onboarding form fires off a Welcome email plus a Slack notification plus a new database row, all in one composed flow.
Workflows compose with Views (trigger on record events), Forms (trigger on submissions), Approvals (compose with Maker-Checker), and any function you've deployed in Forge → Functions.
Setting policies that govern the rest
The Govern cluster covers the meta-rules — what's allowed under what conditions, what needs sign-off, what's irreversibly gated.
Policies is JSON policy authoring with a mode toggle to a no-code visual builder. Policies declare what's permitted, what requires Maker-Checker approval, and what's irreversibly gated. They apply to data writes, function invocations, custody descents, anything the gateway evaluates. Published policies surface in Admin → Govern for project admins to manage.
Approvals is your personal Maker-Checker queue — every in-flight action that needs you to sign off, with the change diff, the requester, and the policy that gated it. A daily check-in for governance-class users.
Composing identity flows for end users
Auth Flows is where you compose the identity flows your end users see — the sign-in screen, the magic-link redemption page, the MFA challenge, the password-reset flow, the invitation acceptance. The designer is the Gate Studio extension; what you author becomes the runtime auth experience your application's customers interact with.
This is the end-user identity surface — the people your application authenticates. It's distinct from the operator-identity surface (who has access to manage the Console) which lives in Admin → Manage.
Authoring composable queries
Data Explorer is a discovery-flavoured authoring surface with three modes — type a natural-language prompt and the platform's default LLM drafts SQL for you; compose a no-code chainable query in a visual builder; or write raw SQL in a code editor. Authored queries get versioned and published as composable artifacts that other Studio entities (Views, Forms, Dashboards) reference by ID. When a developer over in Forge → Queries writes a SQL query and clicks "Save to Studio," the query lands here for the authoring team to refine, version, and compose elsewhere.
How Studio composes with the runtime
Studio is the only mode that authors entities consumed elsewhere. A short tour:
- A View compiles to row-level-security-bound collection queries the Forge → Data plane serves; it renders as a pinned entity in Workspace.
- A Form runs as a capture surface on the Paperless mobile app and as an embedded widget; submissions land back in the View-projected schema.
- A Workflow dispatches against the Forge → Compute runtime when its trigger fires.
- A Policy evaluates at the gateway on every record write that touches its scope.
- An Auth Flow runs as your end users' sign-in screen, served by the gateway under your project's identity surface.
- A Data Explorer query compiles to SQL the data plane runs, and the published version is what Views, Forms, and Dashboards cite by ID.
Author here, runtime everywhere else. That's Studio.
See also
- Orientation — the five modes at a glance.
- Forge — for developer work; Forge consumes most of what you publish here.
- Workspace — the consumption surface for what you build under Compose.
- Gate Studio — the visual sign-in authoring extension behind Auth Flows.
- API → Control — the policy substrate behind Govern.
- API → Data — the data substrate behind Views and Forms.
- API → Compute — the runtime behind Workflows.