Quick facts
- Price
- $299.00 USD
- Odoo versions
- 17, 18, 19
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
One-time Purchase
BPMN Workflow Designer
A build-to-order visual BPMN 2.0 workflow builder for Odoo that lets your team design multi-level approvals and conditional routing without writing XML or Python. ECOSIRE scopes, builds, installs, and supports it on your Odoo 17, 18, or 19 database.
$299.00USD
No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.
Key Features
OWL-based drag-and-drop BPMN 2.0 canvas embedded in the Odoo backend, storing designs as standard interchangeable BPMN XML on the process record
New `bpmn.process`, `bpmn.process.instance`, and `bpmn.task` models built on `models.Model`, with a `state` field whose transitions are driven by the diagram rather than hand-coded branches
Exclusive, parallel, and inclusive gateways compiled into sandboxed Odoo domain expressions evaluated against the source record — no Python edits to change a routing rule
Multi-level and matrix approvals defined as data (`res.groups`, users, amount thresholds) so business users re-route without a module redeploy
Step assignments generated as `mail.activity` records with due dates, so approvers see work in their standard Odoo activity inbox and My Activities view
SLA escalation timers driven by `ir.cron` — a stalled node auto-reassigns, notifies a manager, or triggers a fallback branch
Server-side actions emitted as `ir.actions.server` steps (field updates, email, record creation) wired to node transitions
Full per-instance audit trail — node, actor, timestamp, decision — logged to `mail.thread` chatter and queryable over XML-RPC/JSON-RPC
Conditional start triggers via record create/write hooks or `base.automation`, so a workflow launches automatically when a document meets defined criteria
Access enforced through generated `ir.model.access.csv` entries plus record rules, so approvers only see and act on records within their scope
QWeb approval-history report renderable onto the source document (PO, expense, invoice) for compliance sign-off
Reusable sub-processes and swimlanes to model cross-department handoffs (e.g. finance, legal, procurement) on one canvas
Versioned workflow definitions with activation dates, so in-flight instances finish on the routing they started under while new ones use the updated design
Optional external-signal REST endpoint so an approve/reject action can be driven from email links or an integrated portal, validated server-side
About this Product
Approvals in Odoo are scattered. Purchase orders have a confirm button, expenses have their own manager check, sales quotations lean on discount limits, and everything else falls back to base.automation rules that a business user cannot see, edit, or trust. When finance asks for a three-level sign-off that depends on amount thresholds, department, and whether a contract is attached, you are suddenly writing Python @api.constrains, editing ir.model.access.csv, and redeploying. A month later nobody remembers why a record is stuck. Odoo's native Approvals app covers simple linear requests, but it does not model parallel gateways, conditional branches, escalation timers, or a single visual map of how work actually flows. That is where the native platform runs out of road.
Why Choose BPMN Workflow Designer
OWL-based drag-and-drop BPMN 2.0 canvas embedded in the Odoo backend, storing designs as standard interchangeable BPMN XML on the process record
New `bpmn.process`, `bpmn.process.instance`, and `bpmn.task` models built on `models.Model`, with a `state` field whose transitions are driven by the diagram rather than hand-coded branches
Exclusive, parallel, and inclusive gateways compiled into sandboxed Odoo domain expressions evaluated against the source record — no Python edits to change a routing rule
Multi-level and matrix approvals defined as data (`res.groups`, users, amount thresholds) so business users re-route without a module redeploy
Step assignments generated as `mail.activity` records with due dates, so approvers see work in their standard Odoo activity inbox and My Activities view
SLA escalation timers driven by `ir.cron` — a stalled node auto-reassigns, notifies a manager, or triggers a fallback branch
We build a BPMN Workflow Designer tailored to your database: a drag-and-drop canvas grounded in BPMN 2.0 notation (user tasks, exclusive and parallel gateways, start and end events, swimlanes) that compiles into real Odoo behaviour. Under the hood it is a proper Odoo module — new bpmn.process, bpmn.process.instance, and bpmn.task models built on models.Model, with an OWL-based diagram editor rendered in the backend and the design persisted as standard BPMN XML on the record. When a modeller draws an approval gate, the designer generates the underlying routing: server actions via ir.actions.server, activity assignments through mail.activity, and a state field whose transitions are driven by the diagram rather than hand-coded if branches.
Because it is generated as a versioned module rather than clicked together in the UI, the workflow logic is auditable and portable. Conditions on gateways compile to safe, sandboxed domain expressions evaluated against the source record, so a branch like "amount over 50,000 and no framework agreement" is stored declaratively, not buried in Python. Every process instance keeps a full audit trail — who approved, when, on which node — surfaced in the chatter through mail.thread and available over the XML-RPC/JSON-RPC API for BI or external systems. Escalation timers use ir.cron and Odoo's activity scheduling so a step that stalls past its SLA reassigns or notifies automatically. Approval matrices are data (res.groups, users, and thresholds), not code, so your team edits routing without a redeploy. QWeb reports can render the full approval history onto the source document for compliance sign-off.
Because this is build-to-order, nothing ships until we agree on scope. We start with a scoping call to map which models the workflows govern (purchases, expenses, sales, custom objects), your approval hierarchy, escalation rules, and Community-vs-Enterprise constraints. We build against your exact Odoo version (17.0, 18.0, or 19.0), validate on a staging copy of your database, and hand over installable source with a git repository. Typical delivery is 2–4 weeks from confirmed scope, depending on the number of workflows and integrations. Pricing starts from $299 (indicative, single-company base scope); multi-company routing, deep integrations with third-party systems, and additional governed models increase the quoted scope.
What you get
- Installable, version-pinned Odoo module source for your target version (17.0, 18.0, or 19.0), including `__manifest__.py`, models, OWL views, security, and QWeb reports
- Installation and configuration on your environment, plus workflow setup for the processes agreed during scoping
- Technical documentation: data model, gateway/condition reference, extension points, and upgrade notes
- End-user guide plus a live training session for your workflow modellers and approvers
- Post-go-live support window for defect fixes and configuration questions
- UAT on a staging copy of your database with a documented rollback plan before production cut-over
- Private git repository handover with full commit history and tagged release
- Approval-matrix and escalation configuration documented so your team can maintain routing after handover
Who this is for
Finance & Controlling Lead
Needs enforceable multi-level sign-off on purchases, expenses, and vendor bills with amount thresholds and a defensible audit trail. Wants routing they can adjust as approval limits change, without raising a developer ticket each time.
Operations / Process Owner
Runs cross-department handoffs (procurement to legal to finance) and wants one visual map of how a request actually moves, with escalation when a step stalls past its SLA — instead of chasing records stuck in an invisible automated action.
Odoo Administrator / Internal IT
Manages the Odoo database and is tired of maintaining brittle `base.automation` rules and one-off Python constraints. Wants declarative, versioned workflow logic in a git repo that survives upgrades and is auditable.
Compliance / Audit Manager
Requires proof of who approved what and when, rendered onto the source document, plus role-scoped access so approvers only see records within their remit. Needs the history exportable over the API for reporting.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the BPMN Workflow Designer module ZIP from your account dashboard.
Upload to Odoo
Extract the ZIP into your Odoo custom addons folder on the server (or upload via Apps > Install from file on Odoo.sh / runbot).
Install the module
Activate Developer Mode, open Apps, click Update Apps List, search for BPMN Workflow Designer, and press Install.
Configure settings
Open the new menu, paste your ECOSIRE license key, connect any external credentials (Shopify, Amazon, Stripe, etc.), and save.
Verify & go live
Run the built-in connection test, sync your first 10 records, and schedule the recurring cron. Contact support if anything fails.
How BPMN Workflow Designer Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Fit to your process | Built to your exact approval hierarchy and models after a scoping call | Fully bespoke but you own all analysis and design risk | Generic feature set; you bend your process to fit it | |
| Conditional & parallel routing | BPMN gateways compiled to sandboxed domain expressions | Possible, but hand-coded branch logic in Python | Limited to the vendor's predefined branch options | |
| Who can change routing | Business users edit matrices and thresholds as data, no redeploy | Usually requires a developer for every change | Config UI, but constrained to the module's model | |
| Escalation & SLA timers | `ir.cron`-driven auto-reassign, notify, or fallback branch | Buildable but another custom subsystem to maintain | Sometimes available; behaviour fixed by the vendor | |
| Audit trail & compliance | Per-node actor/timestamp log in chatter + QWeb history report | Only what you specify and build | Vendor-defined logging, variable depth | |
| Ownership & maintainability | Full source + git repo handover, versioned workflow definitions | You own it, but from a blank sheet | Closed module; locked to vendor release cycle | |
| Odoo version support | Built and tested against your 17.0 / 18.0 / 19.0 database | Depends on your team's version expertise | Whatever versions the vendor chooses to publish | |
| Total cost path | Indicative from $299, fixed quote after scoping; no per-user license | Highest upfront analysis + build cost | Low sticker price, but rework to fit and vendor lock-in |
Frequently Asked Questions about BPMN Workflow Designer
Is this an existing app I can download and install today?
No. This is a build-to-order product. ECOSIRE designs, builds, and installs the module for your specific Odoo database and requirements — it is not an off-the-shelf apps.odoo.com download. You receive installable source and a git repository as part of the handover, but the module is produced after we scope your workflows together.
How long does delivery take?
Typical delivery is 2–4 weeks from confirmed scope. The exact timeline depends on how many workflows we build, the number of Odoo models they govern, and any integrations. We confirm a schedule with you after the scoping call, and validate everything on a staging copy of your database before go-live.
How does pricing and scoping work?
Pricing starts from $299 as an indicative figure for a single-company base scope. It is not a fixed price — after a short scoping call we send a fixed written quote based on the number of workflows, governed models, multi-company needs, and integrations. Drivers like multi-company routing, external-system integrations, and additional models increase the quoted scope.
Which Odoo versions do you support, and does it work on Community?
We build against Odoo 17.0, 18.0, or 19.0 — you tell us your version and edition. The designer is implemented with standard framework primitives (ORM, OWL, `ir.actions.server`, `ir.cron`, `mail.activity`), so it runs on Community as well as Enterprise. Where a feature depends on an Enterprise-only app in your database, we confirm that during scoping.
What about support and updates after go-live?
Every build includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full source in a git repository, your team can maintain routing (approval matrices, thresholds) themselves. We also offer ongoing support and version-migration engagements separately if you want us to carry it forward to future Odoo releases.
Can business users change approval routing without a developer?
Yes — that is the core intent. Approval matrices, thresholds, and assignees are stored as data (`res.groups`, users, and configuration records), and gateway conditions are declarative domain expressions rather than Python. Your team re-routes without a code change or redeploy. Structural changes to a workflow diagram are done on the visual canvas.
Will it integrate with our existing approvals and other systems?
Yes. Workflows can govern native models (purchase, expense, sales, invoicing) and your custom models, trigger `ir.actions.server` steps, and expose the full history over the XML-RPC/JSON-RPC API for BI or external systems. An optional server-validated REST endpoint lets approve/reject actions come from email links or an integrated portal. Integration depth is agreed during scoping.
Related Modules
Request a quote
BPMN Workflow Designer
A build-to-order visual BPMN 2.0 workflow builder for Odoo that lets your team design multi-level approvals and conditional routing without writing XML or Python. ECOSIRE scopes, builds, installs, and supports it on your Odoo 17, 18, or 19 database.
- OWL-based drag-and-drop BPMN 2.0 canvas embedded in the Odoo backend, storing designs as standard interchangeable BPMN XML on the process record
- New `bpmn.process`, `bpmn.process.instance`, and `bpmn.task` models built on `models.Model`, with a `state` field whose transitions are driven by the diagram rather than hand-coded branches
- Exclusive, parallel, and inclusive gateways compiled into sandboxed Odoo domain expressions evaluated against the source record — no Python edits to change a routing rule
- Multi-level and matrix approvals defined as data (`res.groups`, users, amount thresholds) so business users re-route without a module redeploy