Flow: object types and fields
Everything stored in Flow is an object: tasks, deals, contacts, requests. An object type describes which fields its objects have, which process they move through and how they are displayed. This article explains how to create a type from scratch, from a preset or from a file, how to change its name and icon, add fields, enable subtasks, link types to each other, and what happens when you publish the schema.
To open type settings, go to the workspace → "Settings" → the "Types and fields" tab. Types can be changed by a member with permission to manage the schema (usually the workspace owner and admins).
Type list
The "Types and fields" tab shows all the workspace's types, including archived ones:
Column | What it shows |
|---|---|
Type | The name; an archived type is marked "archived" |
Key | A permanent Latin key, for example |
Schema | "published" or "unpublished", plus "has a draft" if the type has unpublished changes |
Lifecycle | "yes" if the type has a process with statuses set up |
Click a name to open the type's settings.
Creating a type
Below the list is the "New type" form. First choose what to start from by picking a tile:
Tile | What gets created |
|---|---|
"Blank type" | Just the name: you set up fields, statuses and views yourself |
"Tasks" | Team tasks: description, checklist, priority, labels, start date, due date, watchers, subtasks. Statuses "New" → "In progress" → "Done", plus "Cancelled". Views "Board", "All tasks", "Calendar", "My tasks", a due date reminder and notifications |
"IT tasks" | Bugs, improvements and tech debt: type, priority, story points, component, link to PR or branch, blockers, subtasks — and a second type, "Sprint". Statuses "Backlog" → "Ready" → "In progress" → "Review" → "Testing" → "Done". A sprint board, backlog, a "Sprint" dashboard with burndown; unfinished tasks of a closed sprint move to the next one |
"Purchases" | Purchase requests: what we're buying, quantity, vendor, amount, invoice number, the "Needed by" due date. Statuses "Request" → "Pending approval" → "Ordered" → "Delivered" → "Paid". Process-based approval, a delivery due date reminder, a "Purchases" dashboard |
"Upload template" | A type from a template file — see "Type template files" below |
Below the tiles of a ready-made type you see a "Will be created: …" line — the number of fields, statuses, views, automations, reminders, processes and dashboards. Preset names are created in your interface language.
Then fill in the fields:
Name — in the singular, for example "Deal".
Plural — for example "Deals"; this is what the type is called in the left column and in the table header.
Key — filled in automatically from the name in Latin letters: "Sales deal" →
sales_deal. You can replace the key with your own, for exampledeal: the form keeps only lowercase Latin letters, digits and "_" in it, and transliterates letters from other alphabets into Latin. If you clear the key, it follows the name again. A key is up to 64 characters, starts with a letter, cannot be changed after creation and is used in the API and in URLs.
A preset fills in its own name and key; you can adjust everything before creating. If the preset's key is already taken in the workspace, Flow suggests a free one ending in _2, _3 and so on. A key you entered yourself must be free.
After "Create type", Flow opens the new type's settings, and the type appears in the left column. A blank type is ready to use right away: it already has a published schema with built-in fields. You can create objects and set up the process, rules and automations immediately. You add your own fields in the "Schema and fields" section (see below). A preset creates everything at once, in a single action: if even one step fails, nothing is created.
A blank type can be created by a member with permission to manage the schema. A preset or a template file also requires permissions for views, automations and processes — the workspace owner and admins have them.
Name and icon
The "Name and icon" button in the type settings header opens a window with the "Name" and "Plural" fields and an "Icon" picker. After "Save", the new name and icon appear in the left column, tables and cards.
You can pick an icon from the set or leave it on "Auto". In "Auto" mode, Flow picks an icon based on the meaning of the type's key and name, in Russian and English: tasks — a check mark, purchases — a cart, projects — a folder, milestones and goals — a flag, sprints — a lightning bolt, deals — a briefcase, companies — a building, contacts and employees — a person, customers and teams — a group of people, invoices and payments — a receipt, delivery — a truck, products and orders — a box, contracts and documents — a document, meetings and events — a calendar, bugs — a bug, releases — a rocket, applications and requests — a wrench, risks and checks — a shield. If the meaning isn't recognized, the "layers" icon is used. An icon chosen manually is saved and does not change when you rename the type.
The type key does not change when you rename the type, so objects, views, automations, relations, links and integrations keep working. If you need a different key, create a new type.
An archived type's name and icon cannot be changed. The base "Task" type in the personal Main workspace cannot be changed either: it has no such button. The name and icon can be changed by a member with permission to manage the schema.
Type template files
You can download a configured type as a file and use it to create the same type in another workspace — yours or someone else's.
Download. The "Download template" button in the type settings header saves a file named after the type and ending in
.sensever-flow.json. The button is available for a published, non-archived type and is visible to the workspace owner and admins. The file contains fields, the status process, rules, shared views, action buttons, automations, reminders, the type's processes, the type's relations to itself (subtasks, blockers) and shared dashboards with its views. Data — objects, files, comments, members — is not in the file. Relations to other types and everything that depends on them are not carried over; neither are automations that call an external URL. If something was left out, Flow says "Template downloaded. Left out: N (webhooks, links to people)".Create from a file. In the "New type" form, click the last tile, "Upload template", and choose the file. A tile appears with the type name from the file and the number of fields, views and automations; the name and plural are filled into the form. Adjust them if needed and click "Create type". Keys that are already taken get an
_2,_3ending.
Flow rejects a file larger than 1 MB or in the wrong format: "This is not a Sensever Flow template file." A whole-workspace file cannot be uploaded in "New type" — you upload it when creating a workspace (see Flow: workspaces and templates).
Type settings sections
The type page is split into sections:
Section | What you configure | Article |
|---|---|---|
Schema and fields | Fields and schema versions | this article |
Relations | Relation types to other types | this article |
Process and statuses | Statuses, transitions, SLA | |
Rules | Data checks (constraints) | this article |
Actions | Action buttons on an object | this article |
Automations | Triggers, conditions and actions | |
Reminders | Due date reminders | |
Card | Which fields are shown at the top of the card | this article |
Views | Saved tables, boards, calendars, timelines |
Built-in fields
Every object of every type has these properties. They are not added as fields, and their keys cannot be used by your own field:
Field | Key | What it is |
|---|---|---|
Name |
| The text at the top of the card; used for search |
Status |
| A status from the type's process |
Assignee |
| A workspace member |
Author |
| Filled in automatically |
Created |
| Filled in automatically |
Updated |
| Filled in automatically |
The system keys id, type, version, state, archived_at, schema_version, lifecycle_version, relations and fields are also reserved. If you enter such a key, the field form prompts you to choose another one.
Field data types
Data type in the interface | API key | What it stores |
|---|---|---|
Text |
| Short text |
Long text |
| Long text, a description |
Number |
| A decimal number |
Integer |
| A whole number |
Money |
| An amount and currency |
Yes/No |
| A checkbox |
Date |
| A day without a time |
Date and time |
| A point in time |
Select |
| One value from a set of options |
Multi-select |
| Several values from a set of options |
Member |
| One workspace member |
Members |
| Several members |
Relation |
| Related objects of another type or the same type |
JSON |
| Arbitrary structured data |
Checklist |
| A list of items with checkmarks: up to 100 items of 500 characters each |
Tags |
| Free-form tags with no predefined options: up to 20 tags of 50 characters each |
A "Date" or "Date and time" field enables the "Calendar" and "Timeline" tabs for the type.
"Checklist" and "Tags" are handy for tasks: a checklist shows "2/7" progress on the board and in the table, and tags are added right in the card, with suggestions from tags already in use. Details are in Flow: subtasks, checklists and tags.
Adding and configuring a field
The "+ Field" and "Publish" buttons are always visible on the "Schema and fields" tab. You don't need to create a draft separately: the first change (a new field, a setting or a field removal) opens a draft automatically. In the version list it is called "Unpublished changes", and a reminder appears above the field table: "There are unpublished changes. Click "Publish" to apply them."
Click "+ Field". In the "New field" window:
Name — what the field is called in the interface, for example "Purchase amount".
Key — filled in automatically from the name in Latin letters: "Purchase amount" →
purchase_amount. You can enter your own key manually; the form cleans it up the same way as a type key. Built-in field keys are taken: the form prompts you to choose another. The key cannot be changed after the field is created.Data type — cannot be changed after the field is created.
Description — a hint for the field.
Required — the object cannot be saved without a value.
Read-only — the value is not changed manually.
Options — for "Select" and "Multi-select": one per line, "key" or "key | label", for example
won | Won.Other settings (JSON) — additional field configuration.
Default value (JSON) — for example
"new"or0.
For a "Relation" field, you also choose the relation type and side: "Outgoing (from)" or "Incoming (to)". Create the relation type beforehand in the "Relations" section.
The "Configure" button on a field opens the same window, and the trash icon removes the field. Changes take effect only after publishing.
Watchers, due date and start date
In workspace templates, tasks and deals have a "Watchers" field (watchers, "Members" type). Watchers receive notifications from template automations together with the assignee or author, for example "Task done". You can add such a field to your own type like any other: "Members" type, key watchers; automations can then choose it as a recipient.
In templates, the due date is stored in the "Due date" field: due_date (date) for tasks and milestones, due_at (date and time) for CRM activities. "All workspaces" mode shows and filters the due date specifically by a field with the key due_date or due_at. Due date reminders can be set up on any date field.
Tasks in the "Simple tasks" and "Tasks" templates and in the presets have a "Start date" field (start_date, date). If a type has both start_date and due_date, the calendar shows the task as a bar from start to due date, and the timeline uses these fields by default. You add such a field to your own type like a regular one: "Date" type, key start_date.
In the Main workspace, the "Description" and "Due date" fields of the "Task" type are base fields: they cannot be removed, and the type itself cannot be archived.
Subtasks
Subtasks are a relation of a type to itself: a task has a "Parent task" field, and the parent has a "Subtasks" list. In the "Simple tasks" and "Tasks" templates and in the "Tasks" and "IT tasks" presets, subtasks are already enabled.
If a type has no subtasks, the "Schema and fields" and "Relations" sections show the hint "Tasks of this type have no subtasks…" with an "Enable subtasks" button. In one action, the button:
creates a "parent — subtasks" relation: a subtask has one parent, and cycles are forbidden;
adds the "Parent task" and "Subtasks" fields (named in the interface language) and publishes the schema;
for a type with statuses, adds the rule "A task with open subtasks cannot be completed".
After that, a "Subtasks" block appears in the card, and a "3/5" counter appears on the board and in the table. If the schema has unpublished changes, the fields go into the draft: Flow asks you to publish it, and in this case the rule is not created. How to work with subtasks is covered in Flow: subtasks, checklists and tags.
Schema publishing and versions
A schema has versions with statuses:
Status | What it means |
|---|---|
"Unpublished changes" | A draft; one per type. It appears on the first schema change and has no number yet |
published | In effect; the latest published version is the current one, and new objects are created on it |
retired | An old version with no objects left on it; nothing uses it anymore |
The "Publish" button is active only when the draft differs from the published schema. Publishing makes the draft the current version, and only at that moment does it get a number: "Version 3 — published". If the schema has errors, publishing fails, and the list of errors is shown above the field table. The next change opens a draft automatically again. Old versions in the list are view-only.
A published version never changes: changes always go through a new version.
Existing objects after publishing
Each object is stored on a specific schema version, and the card shows the fields of that version. So after publishing, existing objects need to be moved to the new version — otherwise they won't have the new fields. How this happens depends on the changes.
Safe changes — objects are moved automatically. Flow moves them in the background right after "Publish", and a notification says: "Schema published: N objects are moving to the new version". This usually takes seconds. Safe changes are:
a new optional field or relation field;
a new required field with a default value: objects get that value;
label, description, field order, "Read-only", default value, index;
new list options, new currencies;
looser field limits, for example a longer string length.
Unsafe changes — moved only on your command. If a change could lose data or make objects invalid, Flow leaves the objects alone. Unsafe changes are:
Change | How it's shown |
|---|---|
A field was removed from the schema | "field removed" |
A new required field without a default value | "new required field without a default value" |
An optional field became required | "field became required" |
A field key has a different data type | "field type changed" |
Options were removed from a list | "options removed" |
A field limit became stricter: shorter length, fewer items or a narrower range, fewer decimal places, currencies removed | "limit became stricter" |
In that case, a warning "N objects on older schema versions" stays above the field table, with a "Move to current" button and a list of versions: for each, how many objects are on it and what changed ("changes are safe" or the reasons from the table). Below the heading is an explanation: "Such objects show the fields of their own version: new fields are missing from their card." The same warning appears for objects left on old versions from earlier publications. The button is visible to those who can manage the schema.
"Move to current" opens the "Move objects to the current schema version?" window with the consequences, and the "Move objects" button starts the move:
values of removed fields are dropped from objects and remain in the change history;
objects without a value for a new required field stay on the old version: fill in the field and repeat the move;
objects with removed list options, or with values that don't pass the new limits or the new field type, stay on the old version;
the type's rules are checked for each object; objects that violate them also stay on the old version.
The move runs in the background. When it finishes, Flow says "Moved to the current version: N. Left on the old version: M." The "Why objects were not moved" button shows such objects with an "Open object" link and the reason. Fix them and click "Move to current" again. A repeated move does not touch objects that were already moved.
A version with no objects left on it becomes "retired".
The status process is migrated separately: when you publish a process, Flow asks where to move objects from deleted statuses (see Flow: statuses and the process editor).
Field indexes
Fields in the published version have a "Turn on index" button (except relations and JSON). The index is built in the background, and the field gets an "indexed" mark. An index is needed for fast filtering and sorting on large volumes: if a table or board filters by a field without an index, a hint "Fields without an index: …" appears above the list. "Turn off index" removes it.
Relations between types
The "Relations" section shows the relation types the type takes part in, and a "New relation from "…"" form:
Key, Name (forward) and Name (reverse) — for example "Company" and "Deals".
To type — the type on the other side; you can choose the same type.
Cardinality — "one to one", "one to many", "many to one", "many to many".
On archive — what to do with related objects when an object is archived: "restrict", "cascade" or "unlink".
Object version increases for — "nobody", "the source", "the target" or "both": whose version changes when a relation is added or removed.
Forbid cycles — for a relation of a type to itself, for example "Blocked by" for tasks.
To make the relation appear in the object form, add a "Relation" field with this relation type to the schema draft and publish the schema.
Card
The "Card" section sets what is shown at the top of an object card. The name and date are always at the top; "Date under the title" is a date field or "Date created". In "Card fields (up to 20)", check the fields to show under the name. The other fields remain in the card behind the "More fields" button.
Rules
The "Rules" section holds data checks (constraints). A rule forbids an operation if its violation_when expression is true, and shows its own error text. An example from the "New rule" form:
{
"key": "amount_positive",
"name": "Amount greater than zero",
"operations": ["create", "update"],
"violation_when": "data.amount.amount <= 0",
"error_code": "AMOUNT_NOT_POSITIVE",
"error_message": "The amount must be greater than zero",
"priority": 100
}Operations a rule checks: create, update, archive, restore, transition, relation.add, relation.remove. A rule is saved as a draft ("Save draft") and takes effect after "Publish". "Turn off" and "Turn on" stop and restore a published rule. The expression language is described in Flow API: automations, reminders and expressions.
Actions
The "Actions" section adds your own buttons to an object. Action kinds:
Kind | What it does |
|---|---|
transition | Performs a process transition, with a field form if needed |
field form | Changes the specified fields |
process | Starts a process of the type (chosen in the "Process" list) |
An action is described in JSON: key, label, kind, settings and where it is shown (placement, for example detail — the card, board — the board, list — the list). The "Template: start process" button fills in an example for a process. Actions can be turned off and deleted. If an action is currently unavailable, the reason is shown next to the button.
Archiving and deleting a type
"Archive type" — the type disappears from the left column, and new objects cannot be created. Objects, their history and all settings are kept.
"Delete type" — deletes the type with all its schema versions, with no way to restore it. The button is shown only for a non-system type with no published schema versions. If anything references the type (objects, a process, views, rules, automations, relations, indexes), the deletion is canceled, and the window offers "Archive instead of deleting".
System types from templates cannot be deleted. The key of a deleted type can be reused.
What's next
Flow: statuses and the process editor — statuses, transitions and why the status type matters.
Flow: table, board, calendar and filters — how to work with a type's objects.
Flow: subtasks, checklists and tags — task structure.
Flow: CSV import and export — importing objects from a spreadsheet.
Comments