Skip to content

Migrating from Pipefy to DueReason

Pipefy is a Kanban-style process builder with approval stages and 300+ integrations. See what one stage moved to DueReason's signed grant changes.

Updated · 8 min read

In short

  • Pipefy is a Kanban-style, low-code process and workflow builder - forms, configurable pipes with approval stages, and 300+ integrations, priced from a free tier up to roughly $10-33/user/month depending on plan.
  • It is the closest general-purpose, build-your-own-process alternative to DueReason, but an approval stage in a pipe is still just a stage: moving a card past it does not hand the next system a signed, independently verifiable object to check before anything happens.
  • DueReason does not replace a configurable Kanban board or Pipefy's 300+ integrations - it answers one narrower question, with a signed grant, a hash-chained ledger and an agent-native surface behind the answer.
  • Moving one approval stage over does not mean moving the whole pipe: keep Pipefy for the process you built around it, and add DueReason for the specific decision that needs a record someone else can verify.

If your team builds its own process in Pipefy - a pipe of stages a card moves through, with a form at the start and an approval stage somewhere in the middle - this walks through what that approval stage does today, and what changes if you move just that one stage to DueReason.

What Pipefy does today

Pipefy is a low-code process and workflow builder: you design a "pipe" as a sequence of Kanban-style stages, define the form that opens a card, and configure who can move a card from one stage to the next - including an approval stage that blocks progress until the right person acts on it. It ships with 300+ integrations and connectors, a free tier, and paid plans from roughly $10 to $33 per user per month depending on the plan (sources disagree on the exact current tiers). Because a pipe is fully configurable, teams use it for far more than approvals - onboarding, procurement intake, support triage, almost any process with stages and forms.

That breadth is also why an approval stage inside it is a general building block rather than a dedicated one: it is one stage type among many a pipe can have, built to fit whatever process you modeled, not a decision object with its own identity, signature or lifecycle independent of the pipe that contains it.

What happens after a card moves to "approved"

An approval stage in Pipefy blocks a card until an assigned person approves or rejects it, then lets the card move to the next stage, where automations, webhooks or one of Pipefy's 300+ integrations can act on it. 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 card having moved past the stage inside Pipefy's own board, the same gap the Power Automate migration guide describes for a flow that resumes after an approval action with no record a downstream system can check on its own. A card moving stages is also built around a person or an automation already inside Pipefy doing the moving; nothing in that mechanism is a published, agent-native way to file and wait on a request from outside the board entirely.

The same shape in DueReason

Pipefy's stages are general-purpose, so no single DueReason template is a 1:1 replacement for a whole pipe - DueReason answers the approval question a stage asks, not the rest of the process around it. Map the stage, not the pipe: if the stage you want to move gates spend, Payments and refunds or Vendor onboarding from Settings → Templates cover that shape directly; for a stage with no close template match, a custom DueReason action models the same approve/reject question with its own approver group.

Whichever action models the stage, 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 card is sitting in the right column on the right board.

What changes, not just what moves

  • A grant the acting system checks, not a card position 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 card happened to be in the "approved" column.
  • A hash-chained ledger, not a board's own activity history. 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 board that hosted the approval stage.
  • An agent-native surface, not a card that only moves when a person or a connected automation moves it. 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 card or a board involved at all.
  • One narrow question, not a configurable process. DueReason does not model stages, forms or a Kanban board of its own - it answers whether one specific action is approved, by whom, with what evidence, which is a smaller and more specific surface than a pipe by design.

Moving one approval stage over

  1. Pick the one approval stage you want to move - not the whole pipe - 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 stage as members of the action's approver group, in place of the stage's assignment rule in Pipefy.
  3. For cards still opened by hand, the console request form replaces moving a card into the approval stage: pick the action, attach whatever the form used to collect, write a reason.
  4. For cards your automations or one of Pipefy's integrations create 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 card entered the approval stage.
  5. Replace whatever reads a card's "approved" position back into the rest of your pipe 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 card's column.

What has no direct equivalent

DueReason has no configurable Kanban board, no form builder, and nowhere near Pipefy's 300+ integrations - it is not a process-builder replacement and does not try to be. If the real value you get from Pipefy is the whole pipe - the stages before and after approval, the forms, the connectors - keep Pipefy for that and add DueReason around the one stage that needs a signed, independently verifiable decision rather than expecting a native replacement for the board itself.

Questions

Does moving to DueReason mean rebuilding our whole Pipefy process?
No. DueReason replaces one approval stage at a time, not a whole pipe. Keep Pipefy for the stages, forms and integrations around it, and point the one stage that needs a signed, verifiable decision at a DueReason action instead.
Does DueReason have Pipefy's 300+ integrations?
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 general connector library the way a process builder does.
What does Pipefy cost, compared to DueReason?
Pipefy has a free tier, with paid plans reported from roughly $10 to $33 per user per month depending on the plan (third-party sources disagree on exact current tiers, so treat any number as unverified until quoted directly). DueReason is free today for one organization with up to five members, all core features included.
Do I need engineering to move one approval stage 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 moving a card by hand in Pipefy; 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 board or connector 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 stage to DueReason

Keep Pipefy for the process around it - point requestApproval() and waitForApproval(), or the console request form, at the one stage 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