Your approval flow has opinions
Multi-level approvals with conditions that standard rules can't express.
Odoo covers most of a business out of the box. The workflows that make you different need custom code. We build modules that are tested, documented, and still readable after the next upgrade.
Inherit, don't patch. Test, don't hope. Document, don't remember.
Every custom line of code is something you'll maintain through every future upgrade. So the first question isn't how to build a feature; it's whether it needs building at all. A surprising number of requests turn out to be configuration, a standard app nobody had switched on, or an automated action.
When code is the right answer, it should behave like part of Odoo: extending standard models through inheritance, respecting access rules, and following the same conventions as the modules around it. That's what keeps an upgrade a planned task rather than an archaeology project.
We pick the lightest tool that solves the problem well.
| Need | Best tool | Why |
|---|---|---|
| Extra fields, views, or simple filters | Configuration or Studio | No code to maintain; survives upgrades well |
| Notifications and simple automations | Automated actions | Built in, auditable, and editable by admins |
| Business rules with real logic | Custom module (Python) | Testable, versioned, and reviewable |
| New screens or interactive widgets | Custom module (OWL) | Native look and behavior in the Odoo interface |
| Talking to external systems | Custom module or integration service | Retries, logging, and error handling done properly |
Multi-level approvals with conditions that standard rules can't express.
Contract pricing, rebates, or cost allocation logic unique to your trade.
Industry hardware, a regulator's portal, or an in-house tool that must stay.
A screen that needs five clicks for a task done fifty times a day.
Statutory or management reports with layouts and rules beyond the standard.
Plain Python on top of the Odoo ORM. Computed fields declare their dependencies, so Odoo knows exactly when to recompute and can store results for fast search and reporting.
from odoo import api, fields, models
class ProjectCostLine(models.Model):
_name = "project.cost.line"
_description = "Project Cost Allocation"
project_id = fields.Many2one("project.project", required=True, index=True)
analytic_account_id = fields.Many2one("account.analytic.account")
currency_id = fields.Many2one(related="project_id.currency_id", store=True)
amount = fields.Monetary(currency_field="currency_id")
allocated_pct = fields.Float(string="Allocation %", default=100.0)
allocated_amount = fields.Monetary(
compute="_compute_allocated_amount", store=True,
)
@api.depends("amount", "allocated_pct")
def _compute_allocated_amount(self):
for line in self:
line.allocated_amount = line.amount * line.allocated_pct / 100Custom Odoo code has a reputation for being fragile and undocumented. These rules exist to prove that reputation wrong.
What we won't do
Patch Odoo's core source. It turns every upgrade into archaeology, creates security gaps, and breaks the moment Odoo ships a fix. Inheritance exists for a reason, so we use it.
Step 01
Agree the behavior, edge cases, and acceptance tests in writing, in business language your team can review.
Step 02
Choose models, inheritance points, views, and access rules. Check once more what standard Odoo already offers.
Step 03
Implement in small, reviewed commits with tests running in CI against a realistic copy of your data.
Step 04
Your team tries it with real scenarios before anything touches production.
Step 05
Release through a repeatable deployment, then hand over the README, admin notes, and test results.
Myth: Studio can do everything a developer can.
Reality: Studio is great for fields, views, and simple automation. Complex logic, integrations, and anything that needs tests belongs in a real module.
Myth: Custom code always breaks upgrades.
Reality: Core patches and untested code break upgrades. Inheritance-based modules with tests port in a predictable, plannable way.
Before writing a module, we check the Odoo Community Association (OCA) library and the Odoo App Store. Thousands of community modules already solve common gaps, and a well-maintained one can be cheaper than building and owning your own.
We evaluate candidates like any dependency: Is it maintained for your version? Does it have tests? Is the code readable? Who will port it next year? When the answer is shaky, a small purpose-built module is usually the safer choice.
Multi-step approvals for purchases, discounts, and expenses with delegation and audit trails.
Contract pricing, volume tiers, and rebate accruals calculated where sales and accounting meet.
Branded invoices, delivery slips, certificates, and management reports.
Custom putaway rules, packing workflows, and label printing.
Customer and vendor portals for orders, documents, and approvals.
Bridges to industry systems, devices, and government portals.
Estimates are broken into parts you can question, not a single number.
| Part | What it includes |
|---|---|
| Data model | New models, fields, and changes to standard models |
| Business logic | Rules, computations, constraints, and automations |
| Interface | Views, wizards, OWL components, and reports |
| Security | Groups, access rights, and record rules |
| Tests & docs | Automated tests, README, and admin notes |
| Unknowns | Listed explicitly, with how we'll resolve each one |
The best custom modules look like they came with Odoo: same naming, same structure, same patterns. A new developer, or Odoo's own upgrade tooling, should be able to read them without a guided tour. Clever tricks that bypass the ORM or override internals tend to be the first things that break.
Odoo's own developer documentation describes inheritance mechanisms for extending existing models in a modular waySource [1]. That's the foundation of clean custom development: your changes live in their own module, layered on top of standard Odoo, instead of rewriting files that the next update will overwrite.
It matters most at upgrade time. Odoo states that a database with custom modules cannot be upgraded until a version of those modules exists for the target releaseSource [2]. A handful of well-built extensions ports quickly; a pile of core patches can turn an upgrade into a rewrite. That's why we question every customization in discovery and keep the ones we build small, tested, and documented.
Odoo migration
Upgrade Odoo across versions or move from legacy systems with audited modules, cleaned data, rehearsed cutovers, and a real rollback plan.
OdooOdoo integrations
Connect Odoo to Shopify, Stripe, banks, 3PLs, and legacy systems with signed webhooks, idempotent sync, retries, and reconciliation.
TechnologyTech stack & standards
The technologies we use across ERP, web, mobile, AI, and infrastructure, and the engineering standards every project follows.
Next step
Thirty minutes with an engineer, no slide deck required. You'll leave with a clearer picture, whether or not we work together.