Skip to content

Migrating from Process Street to DueReason

Process Street is no-code checklist software with approval steps and forms. See what one approval step gains from DueReason's signed grant and ledger.

Updated · 8 min read

In short

  • Process Street is no-code checklist and workflow software - recurring checklists with forms, conditional logic and an approval step that stops a run until someone acts - priced from about $100/month (effectively $20/user with a 5-user minimum) up to roughly $1,500/month.
  • Its approval step is the closest published shape to DueReason's evidence model - a form field attached to the step - but it is still a checklist task: approving it unblocks the next task in the same run, not a signed, independently verifiable object another system can check.
  • DueReason does not replace Process Street's checklist builder or its conditional logic - it answers the one approval question a checklist step asks, with a signed grant, a hash-chained ledger and an agent-native surface behind the answer.
  • Moving one approval step over does not mean moving the whole checklist: keep Process Street for the recurring process you built around it, and add DueReason for the one step that needs a record someone else can verify.

If your team runs a recurring checklist in Process Street - a sequence of tasks with forms, conditional logic and an approval step that blocks the run until someone signs off - this walks through what that approval step does today, and what changes if you move just that one step to DueReason.

What Process Street does today

Process Street is no-code checklist and workflow software: you build a checklist template out of tasks, attach forms to collect data at each step, add conditional logic so later tasks appear or are skipped based on earlier answers, and mark one or more tasks as an approval - which stops the checklist run until an assigned person approves or rejects it. Pricing starts from about $100/month, which works out to roughly $20 per user with a 5-user minimum, and scales up to around $1,500/month on higher plans. Because a checklist is fully configurable, teams run far more than approvals through it - onboarding, audits, incident response, almost any recurring process with steps and forms.

That breadth is also why an approval task inside it is a feature of the checklist runner rather than a dedicated object: it is one task type among many a run can have, built to fit whatever checklist you modeled, not a decision with its own identity, signature or lifecycle independent of the run that contains it.

What happens after a checklist task is approved

An approval task in Process Street blocks the run until an assigned person approves or rejects it, then lets the run continue to the next task, where a later step, an integration or a person picks up from there. What is not part of that mechanism is a signed, independently verifiable object the next system checks before it acts - the trust sits in the task having been marked approved inside Process Street's own run, the same gap the Pipefy migration guide describes for a card that moves past a stage with no record a downstream system can check on its own. A checklist run is also built around a person working through tasks in order; nothing in that mechanism is a published, agent-native way to file and wait on a request from outside the checklist entirely.

The same shape in DueReason

Process Street's checklists are general-purpose, so no single DueReason template is a 1:1 replacement for a whole checklist - DueReason answers the approval question one task asks, not the rest of the run around it. Map the task, not the checklist: if the task you want to move gates spend, Payments and refunds or Vendor onboarding from Settings → Templates cover that shape directly; for a task with no close template match, a custom DueReason action models the same approve/reject question with its own approver group and its own evidence field in place of the task's form.

Whichever action models the task, once a request is decided DueReason issues a signed, single-use grant bound to the exact payload - the amount, the recipient, the change being requested - which whatever acts next verifies, rather than trusting that the task is marked approved in the right run.

What changes, not just what moves

  • A grant the acting system checks, not a task status trusted at the source. DueReason's signed grant is bound to a hash of the exact payload and verified by whatever executes the decision, so a changed amount or target after approval is refused rather than carried out because a task happened to be marked approved.
  • A hash-chained ledger, not a checklist run's own activity log. Every step of a request - filed, each answer, what happened after - is a ledger event from the start, checkable on its own without opening the checklist that hosted the approval task.
  • Evidence built into the action, not a generic form field. Process Street's form fields can collect anything attached to a task; DueReason's evidence setting (none, text or document) is narrower by design - built into the action definition itself rather than a generic form builder, so the "must attach the invoice" cases are faster to set up and the decision record always carries exactly what the approver was shown.
  • An agent-native surface, not a task that only moves when a person works through the checklist. The same actions are reachable from @duereason/sdk, the MCP server, the GitHub Action or the REST API, so a pipeline or an agent can requestApproval() and waitForApproval() without a checklist run involved at all.

Moving one approval step over

  1. Pick the one approval task you want to move - not the whole checklist - and find the closest DueReason template (Payments and refunds, Vendor onboarding) or define a custom action if nothing close exists yet.
  2. Recreate the people assigned to that task as members of the action's approver group, in place of the task's assignment rule in Process Street.
  3. For checklist runs still started by hand, the console request form replaces reaching the approval task: pick the action, attach whatever the form field used to collect, write a reason.
  4. For runs your integrations start automatically, requestApproval() and waitForApproval() from @duereason/sdk (or the no-code webhook recipe if you would rather not write a backend) replace the point where the run reached the approval task.
  5. Replace whatever reads the task's approved status back into the rest of the checklist or into a downstream integration with a check of decided.status and a verification of decided.grant before the step that actually acts - the system doing the work should check the grant, not just the task status.

What has no direct equivalent

DueReason has no checklist builder, no conditional logic between unrelated tasks, and no recurring-run tracking - it is not a checklist-software replacement and does not try to be. If the real value you get from Process Street is the whole checklist - the tasks before and after approval, the forms, the conditional logic - keep Process Street for that and add DueReason around the one task that needs a signed, independently verifiable decision rather than expecting a native replacement for the checklist itself.

Questions

Does moving to DueReason mean rebuilding our whole Process Street checklist?
No. DueReason replaces one approval task at a time, not a whole checklist. Keep Process Street for the tasks, forms and conditional logic around it, and point the one task that needs a signed, verifiable decision at a DueReason action instead.
Does DueReason do conditional logic and recurring checklist runs like Process Street?
No, and it is not trying to. DueReason answers one question - is this action approved, by whom, with what evidence - and reaches that answer through @duereason/sdk, the MCP server, the GitHub Action or the REST API, rather than offering a checklist builder with branching logic.
What does Process Street cost, compared to DueReason?
Process Street starts from about $100/month, effectively $20 per user with a 5-user minimum, scaling up to roughly $1,500/month on higher plans. DueReason is free today for one organization with up to five members, all core features included.
Do I need engineering to move one approval task over?
No. Picking the closest template, adding people to its approver group, and filing requests from the console form is console-only setup, the same as reaching an approval task by hand in Process Street; engineering is only needed once you want an automation or an agent to request approval through the API instead of a person using the form.
Can I self-host instead of using the hosted product?
Yes. Self-hosting runs on one Postgres database and one pre-built image started with Docker Compose, with no checklist or form configuration of its own - the same actions, grants and ledger work the same way whether you use the hosted product or run it yourself.

Move one approval step to DueReason

Keep Process Street for the checklist around it - point requestApproval() and waitForApproval(), or the console request form, at the one task that needs a signed, verifiable decision.

Create your account

Sources

This guide explains the regulation as we read it; it is not legal advice. Check the official text and your national law, which may add obligations.

Start with DueReason

Create a free account, try it live, or talk to us about your workflow.

Get product updates