Forms is now in beta. It gives organizations a dedicated way to define a schema, publish it behind a shareable link, and collect structured responses without turning the workflow into a one-off field buried inside another feature.
Why we built it
A lot of business workflows start as a form problem: vendor intake, attestations, questionnaires, pre-checks, and internal data collection all need typed fields and durable records. Free-text instructions or ad hoc JSON blobs do not give you that. They are hard to validate, hard to audit, and harder to reuse.
Forms is the smaller, more explicit system: define the fields once, publish the form, collect the answers, and keep the response tied to the exact form version that was active when it was submitted.
What shipped
- Tenant-scoped forms with ordered, typed fields.
- Field types for short text, long text, email, select, checkbox, and date.
- Public share links for external respondents.
- Immutable responses with timestamps and version pinning.
- Response caps, optional expiry, revoke, and archive controls.
- Collaborators and responses managed from the Forms area.
The model is explicit
A form definition is not the same thing as a published collection link. The definition holds the schema. The publication holds the share link, the active collection state, and the version that respondents will see. The response is the immutable record of what was submitted.
Form definition
└── publication link
└── immutable responseThat separation matters. It lets teams update a form without rewriting the record of past submissions, and it keeps active links stable even as the schema evolves.
What this is not
Forms is not a generic survey product, and it is not a replacement for every intake workflow. It is a platform primitive for structured collection. The point is to make the data shape explicit so validation, audit, and reuse stay deterministic.
We also keep the public surface narrow. Respondents follow the share link, complete the form, and submit. Owners and collaborators review responses inside Stellarbridge.
Why that matters
When a system treats forms as first-class data instead of incidental UI, you can enforce the shape of the input, pin the version, and retain the output in a way that survives audits and internal handoffs.
That is the difference between visibility and control. Visibility tells you what happened. A form primitive gives you a repeatable way to make the same thing happen again.
Next
Forms is the standalone starting point. It gives teams a governed place to collect structured responses now, and it creates a clean base for future workflows that need the same schema and the same response record.