Skip to main content
Invoice Multi Level Approval — A build-to-order Odoo approval engine that routes customer invoices, vendor bills, refunds and — 1/1Illustrative preview

A build-to-order Odoo approval engine that routes customer invoices,

vendor bills, refunds and credit notes through configurable multi-level sign-offs before they post.

ECOSIRE scopes, builds, installs and supports it for your Odoo 17, 18 or 19 database.

What is Invoice Multi Level Approval?

A build-to-order Odoo approval engine that routes customer invoices, vendor bills, refunds and credit notes through configurable multi-level sign-offs before they post. ECOSIRE scopes, builds, installs and supports it for your Odoo 17, 18 or 19 database. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Override of `account.move.action_post()` so no invoice, bill, refund or credit note can post while an approval chain is pending — closes UI, batch, cron and XML-RPC/JSON-RPC back doors
Configurable approval-matrix model with tiers keyed by document type, amount threshold, journal, company and analytic distribution
Sequential and parallel approval tiers (e.g. two managers in parallel, then CFO in sequence) resolved by a `@api.depends` compute method
Separate handling for customer invoices, vendor bills, customer refunds and vendor credit notes with independent thresholds per type
State machine on the move: `draft` → `to_approve` → `approved` → `posted`, plus a `refused` branch requiring a mandatory rejection reason
Approver groups defined in `ir.model.access.csv` with record rules scoping each approver to only their tier and company
Immutable audit trail written to the chatter for every approve/refuse action (user, timestamp, level, comment)
QWeb PDF approval certificate report for auditors, showing the full sign-off chain per document
Self-approval prevention and configurable minimum-approver counts to enforce segregation of duties
Delegation / substitute approver support for out-of-office cover, with effective date ranges
Automated actions and scheduled crons for reminder nudges and time-based auto-escalation to the next tier
Smart button on the invoice form plus a dedicated 'My Approvals' OWL dashboard with pending-count filters
Company- and journal-aware rules that work correctly in multi-company Odoo databases and respect the active company context
Delivered for Odoo 17.0, 18.0 and 19.0 with clean `__manifest__.py` dependencies (`account`, `mail`) and no Enterprise-only assumptions

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your Odoo.

  3. 3

    Go live + support

    You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.

Technical Specifications

Odoo Compatibility
Odoo 17, Odoo 18, Odoo 19
Editions
Enterprise & Community
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
PostgreSQL 12+

About this Product

Finance teams running Odoo hit a wall the moment their invoicing volume outgrows a single accountant clicking "Confirm." Out of the box, Odoo lets anyone with Billing rights post a customer invoice, validate a vendor bill, or issue a credit note with no structured sign-off in between. There is no native concept of "this bill over $10,000 needs the department head, then the CFO." The result is uncontrolled spend, weak segregation of duties, audit findings, and credit notes that quietly reverse revenue without anyone senior ever seeing them. Odoo's generic Settings-level approval flags are coarse and do not chain multiple approvers by amount, journal, analytic account, or company.

We build a dedicated multi-level approval engine that sits on top of account.move and gates the transition to posted. The core is a configurable approval-matrix model (models.Model) where you define tiers by document type (customer invoice, vendor bill, customer/vendor refund, credit note), amount thresholds, journal, company, and analytic distribution. When a document is submitted, a compute method (@api.depends on amount, partner, and journal) resolves which tiers apply and generates an ordered chain of approval-request records. State moves through draft → to_approve → approved → posted, with a refused branch that returns the document to the author with a mandatory reason. We override action_post() so an unapproved move can never be posted — via the UI, an imported batch, a scheduled action, or the XML-RPC/JSON-RPC API — closing the back doors that a button-only solution leaves open.

Security is enforced the Odoo-native way: approver rights live in dedicated groups wired through ir.model.access.csv, and record rules ensure an approver only sees requests routed to their tier and company. Each approval writes an immutable audit line (who, when, level, comment) rendered in the chatter and available in a QWeb PDF approval certificate for auditors. Automated actions and server-side crons handle escalation and reminders — for example, nudging an approver after 48 hours or auto-escalating to the next tier. Delegation (out-of-office substitute approvers), parallel vs. sequential tiers, and self-approval prevention are all part of the model. Views are delivered as clean XML/OWL with a smart button showing pending approvals and a dedicated "My Approvals" dashboard, so nothing about the standard Odoo accounting experience feels bolted on. The build respects Community vs. Enterprise differences — we do not assume Studio or Enterprise-only approval primitives are present, and we target Odoo 17.0, 18.0 and 19.0 explicitly.

Because this is build-to-order, nothing ships until we have agreed your approval matrix on a scoping call: your tiers, thresholds, roles, and which document types are in scope. We then build against a copy of your data on a staging database, run UAT with your finance team, and hand over installable source, a git repository, and documentation. Typical delivery is one working week from confirmed scope. Pricing starts from $999 (indicative, single-company base scope); multi-company approval chains, deep localization of tax/credit-note rules, integrations with external procurement or expense systems, and large historical data migration increase the quoted scope. You receive a fixed quote after the scoping call — never a surprise.

What you get

  • Installable source code for your commissioned version, targeting your exact Odoo edition (17.0/18.0/19.0) and Community or Enterprise
  • Installation and configuration on your staging (and, when agreed, production) database, including approval-matrix setup
  • Technical documentation: data model, security groups, record rules, override points and configuration reference
  • End-user guide plus a live training session for your finance and approver teams
  • UAT on a staging copy of your data with a documented rollback plan before any production go-live
  • Post-go-live support window for defect fixes and configuration questions
  • Handover of the full git repository with commit history and tagged release
  • Approval-certificate QWeb report template ready for your auditors, branded to your company

Who this is for

Finance Controller / CFO

Needs enforceable segregation of duties and amount-based sign-off so no bill or credit note posts without the right level of authorization. Wants an audit-ready trail for external auditors and internal controls.

Accounts Payable Manager

Processes high volumes of vendor bills and wants routing by amount and journal so routine bills flow fast while large or unusual ones stop for review. Needs reminders and escalation so nothing sits unapproved.

Odoo Administrator / IT Lead

Runs the Odoo instance and wants a clean, upgrade-safe module with proper `ir.model.access.csv` security, record rules and a git repo — not a Studio hack that breaks on the next migration.

Compliance / Internal Audit Officer

Requires documented approval chains, immutable logs of who approved what and when, and a printable certificate per document to satisfy SOX-style or ISO control requirements.

How Invoice Multi Level Approval Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Multi-level chains by amountUnlimited tiers keyed by amount, journal, company and analytic accountPossible but you design and maintain the matrix logic yourselfUsually fixed tiers with limited threshold conditionsNo amount-based multi-level chaining out of the box
Coverage of refunds & credit notesInvoices, bills, refunds and credit notes each with own thresholdsWhatever you build; refunds often forgottenOften invoices/bills only; refunds patchyNo structured approval for any of them
Enforcement at ORM level`action_post()` override blocks UI, batch, cron and RPC pathsDepends on developer discipline; RPC often left openFrequently button/view-only, leaving API back doorsNo posting gate to enforce
Security & segregation of dutiesDedicated groups, record rules, self-approval preventionYou define and test all access rules yourselfBasic approver group, limited record-rule scopingAny Billing user can post; no separation
Audit trail & certificateImmutable chatter log plus QWeb PDF approval certificateBuild reporting yourselfLog yes, printable certificate often absentStandard chatter only, no approval concept
Fit to your processMatrix agreed on scoping call, built to your rulesFully bespoke but higher cost and longer timelineConfigure within the vendor's fixed feature setYou adapt your process to Odoo, not the reverse
Support & maintenancePost-go-live window, git repo handover, upgrade retainersTied to your in-house or contracted developerGeneric vendor support, upgrade at their cadenceCovered by your Odoo subscription/partner only
Version & edition targetingBuilt for your exact Odoo 17/18/19, Community or EnterpriseWhatever you target and testPrebuilt per version; edition assumptions varyNative behaviour differs per version, no approval added

Frequently Asked Questions about Invoice Multi Level Approval

How long does delivery take?

This is a build-to-order module, not an instant download. Typical delivery is one working week from confirmed scope — that is, after we have agreed your approval matrix, document types, thresholds and target Odoo version on a scoping call. Complex multi-company or heavily localized builds can run longer, and we will tell you honestly during scoping.

How does pricing and scoping work?

Pricing starts from $999 as an indicative figure for a single-company base scope. The final number depends on the number of tiers, document types, multi-company requirements, integrations and any data migration. After a short scoping call we give you a fixed written quote — you approve that before we build, so there are no surprises.

What support and updates do I get after go-live?

Every build includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full git repository and source, your own team can maintain it too. We also offer optional ongoing support and version-upgrade retainers if you want us to keep the module current across future Odoo releases.

Will it work on my Odoo version and edition?

Yes — we build explicitly for Odoo 17.0, 18.0 or 19.0, and for either Community or Enterprise. We do not assume Enterprise-only or Studio features are present, so the approval engine works on Community. We confirm your exact version and edition during scoping and target that build.

Can an invoice still be posted around the approval workflow?

No. We override `account.move.action_post()` at the ORM level, so the block applies everywhere a move can be posted — the UI Confirm button, batch operations, scheduled actions, and the XML-RPC/JSON-RPC API. A button-only or view-only approach leaves those back doors open; ours does not.

Does it handle refunds and credit notes, not just invoices?

Yes. The approval matrix treats customer invoices, vendor bills, customer refunds and vendor credit notes as distinct document types, each with its own thresholds and tiers. This matters because credit notes reverse revenue and are a common control gap — you can require senior sign-off on any refund above a threshold.

How is it kept upgrade-safe and auditable?

The module is delivered as clean, standard Odoo code — a proper `__manifest__.py`, models, security via `ir.model.access.csv` and record rules, XML/OWL views and a QWeb report — with no monkey-patched core files. Every approval writes an immutable chatter log, and a QWeb PDF certificate gives auditors the full sign-off chain per document.

Request a quote

Invoice Multi Level Approval

A build-to-order Odoo approval engine that routes customer invoices, vendor bills, refunds and credit notes through configurable multi-level sign-offs before they post. ECOSIRE scopes, builds, installs and supports it for your Odoo 17, 18 or 19 database.

  • Override of `account.move.action_post()` so no invoice, bill, refund or credit note can post while an approval chain is pending — closes UI, batch, cron and XML-RPC/JSON-RPC back doors
  • Configurable approval-matrix model with tiers keyed by document type, amount threshold, journal, company and analytic distribution
  • Sequential and parallel approval tiers (e.g. two managers in parallel, then CFO in sequence) resolved by a `@api.depends` compute method
  • Separate handling for customer invoices, vendor bills, customer refunds and vendor credit notes with independent thresholds per type

Request a Quotation

Tell us about your Invoice Multi Level Approval requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.