Design your Workflow

Designing a great workflow starts with clarity: what outcomes matter, who’s involved, and how work moves from idea to done. In Stackby, that clarity turns into a flexible system of bases, tables, fields, links, and views—so every stakeholder can focus on the right work at the right time.

Map out your workflow

Before building, chart the path work takes from intake to completion.

• Define goals and success metrics: What must improve—speed, quality, visibility, or compliance?

• List the steps: Capture → Triage → Plan → Execute → Review → Deliver → Report.

• Identify roles and handoffs: Who creates, approves, and signs off? Where do bottlenecks happen?

• Inventory the data: What fields are required at each step (status, owner, due date, tags, files)?

• Decide on checkpoints: Which transitions require approval or automation?

Deliverables:

• A simple swimlane diagram or checklist of stages.

• A list of “entities” (nouns) that become tables (e.g., Projects, Tasks, Clients, Assets).

Bring your workflow into Stackby

Translate the plan into a living system.

• Create stacks by process: e.g., “Editorial Ops,” “Sales Pipeline,” “Product Roadmap.”

• Add tables per entity: Projects, Tasks, Clients, Assets, Requests.

• Choose column types that match needs: single select (Status), date (Due), collaborator (Owner), long text (Notes), attachment (Files).

• Link records to model relationships: Tasks → Projects, Deals → Companies, Requests → Teams.

• Save role-based views:

  • PM: This week (filter: Due this week; sort: Due asc)

  • Design: In progress (filter: Status is In progress)

  • Leadership: Rollup (group by Status; summary fields)

Enhancements:

• Use formulas (e.g., Days remaining).

• Add automations (e.g., notify Owner when Status becomes Blocked).

• Lock critical views to preserve filters/sorts.

Import data from other tools

Start where teams already are by bringing historical data into Stackby.

Import sources:

• CSV/Spreadsheet exports from legacy tools.

• Marketing, CRM, or helpdesk systems via connectors or API.

• Form responses via form view.

Tips for clean imports:

• Normalize column names to match Stackby fields.

• Map statuses and tags to single/multiple select options before import.

• Import foundational tables first (e.g., Companies before Deals) to preserve links.

• After import, create Linked record fields and use lookups/rollups to enrich context.

6 common Stackby design decisions

Use these patterns to avoid rework and keep your system scalable.

1. Single select vs. multiple select

• Single select for mutually exclusive stages (To do/In progress/Done).

• Multiple select for tags (Channel: Email, Social, Events).

2. One table or two tables?

• Split when records represent different entities (Projects vs. Tasks).

• Keep together when entries share identical fields and lifecycle.

3. Linked record vs. single select

• Use Linked record to avoid duplication and enable lookups/rollups.

• Convert a mature single select to a linked table when options become “things” with attributes.

4. Owner vs. Team ownership

• Collaborator field for individual ownership.

• Add a Team single select for visibility and grouped views.

5. Dates and scheduling

• Separate Start date and Due date for duration views (Timeline).

• Use formulas for Days remaining and Overdue flags.

6. Views strategy

• Create role-based saved views; name them clearly (PM: This week, Design: Needs review).

• Lock views that feed reporting or leadership dashboards.

Connect your data with linked records

Linking turns standalone lists into a cohesive, relational system—so updates flow naturally across tables and reporting becomes trustworthy.

• Create Linked record fields to connect related entities (e.g., Tasks → Projects).

• Use Lookups to display key attributes from the linked table (e.g., Client → SLA).

• Use Rollups to summarize numbers across links (e.g., Total budget per Project).

• Add Count fields to measure workload (e.g., Tasks per Owner).

Starter patterns:

• Projects ↔ Tasks (one-to-many)

• Companies ↔ Deals (one-to-many)

• Campaigns ↔ Channels (many-to-many)

• Requests ↔ Approvals (one-to-one or one-to-many)