Skip to main content
Odoo // Custom development

When standard Odoo hits a wall, we build a door.

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.

Backend
Python ORM · controllers
Frontend
OWL components · QWeb
Rule
Zero core patches

Inherit, don't patch. Test, don't hope. Document, don't remember.

Customize the difference, not the basics

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.

Configure, Studio, or code?

We pick the lightest tool that solves the problem well.

NeedBest toolWhy
Extra fields, views, or simple filtersConfiguration or StudioNo code to maintain; survives upgrades well
Notifications and simple automationsAutomated actionsBuilt in, auditable, and editable by admins
Business rules with real logicCustom module (Python)Testable, versioned, and reviewable
New screens or interactive widgetsCustom module (OWL)Native look and behavior in the Odoo interface
Talking to external systemsCustom module or integration serviceRetries, logging, and error handling done properly

Signs you need a custom module

Your approval flow has opinions

Multi-level approvals with conditions that standard rules can't express.

Pricing that needs a whiteboard

Contract pricing, rebates, or cost allocation logic unique to your trade.

A system Odoo doesn't know

Industry hardware, a regulator's portal, or an in-house tool that must stay.

Users fight the interface

A screen that needs five clicks for a task done fifty times a day.

Reports finance actually wants

Statutory or management reports with layouts and rules beyond the standard.

What our modules look like

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.

models/project_cost_line.pypython
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 / 100

Our module standards

Custom Odoo code has a reputation for being fragile and undocumented. These rules exist to prove that reputation wrong.

  • OCA-compatible structure and code style
  • Inheritance and extension points only, never core patches
  • Unit and integration tests shipped with every module
  • README, docstrings, and configuration notes
  • Migration scripts for every data model change
  • Access rights and record rules defined, not left open
  • Peer review before every merge
  • Delivered in your repository, under your ownership

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.

From spec to deployed module

  1. Step 01

    Specify

    Agree the behavior, edge cases, and acceptance tests in writing, in business language your team can review.

  2. Step 02

    Design

    Choose models, inheritance points, views, and access rules. Check once more what standard Odoo already offers.

  3. Step 03

    Build & test

    Implement in small, reviewed commits with tests running in CI against a realistic copy of your data.

  4. Step 04

    Review in staging

    Your team tries it with real scenarios before anything touches production.

  5. Step 05

    Deploy & document

    Release through a repeatable deployment, then hand over the README, admin notes, and test results.

Custom module myths

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.

Reuse before you build

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.

Modules we commonly build

Approval engines

Multi-step approvals for purchases, discounts, and expenses with delegation and audit trails.

Pricing & rebates

Contract pricing, volume tiers, and rebate accruals calculated where sales and accounting meet.

Documents & reports

Branded invoices, delivery slips, certificates, and management reports.

Warehouse extensions

Custom putaway rules, packing workflows, and label printing.

Portals

Customer and vendor portals for orders, documents, and approvals.

Connectors

Bridges to industry systems, devices, and government portals.

How an estimate is structured

Estimates are broken into parts you can question, not a single number.

PartWhat it includes
Data modelNew models, fields, and changes to standard models
Business logicRules, computations, constraints, and automations
InterfaceViews, wizards, OWL components, and reports
SecurityGroups, access rights, and record rules
Tests & docsAutomated tests, README, and admin notes
UnknownsListed explicitly, with how we'll resolve each one

Good custom code is boring code

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.

Why we extend instead of patching

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.

Frequently asked questions

Can you extend an Odoo App Store module we bought?
Usually, through the same inheritance approach, without editing the vendor's code, so you can still take their updates.
How do you test custom modules?
With Odoo's test framework: unit tests for business logic, integration tests that exercise real records, and tours for key interface flows, all running in CI on every change.
Do you use OCA modules?
When a maintained OCA module fits, yes. It's often cheaper than building, and the community shares the porting work across versions.
Will custom modules break our next upgrade?
Inheritance-only modules with tests port far more predictably. Each upgrade still needs review and porting, but there's no hidden core patch waiting to explode.
Do you build OWL frontend components?
Yes: custom widgets, views, dashboards, kiosk screens, and portal pages built with OWL and QWeb that look and behave like native Odoo.
Who owns the code?
Client-funded custom modules belong to you after payment. You get the repository with full history, not just a zip file.
Can you fix modules another partner built?
Yes. We start with a code audit that rates each module for risk, test coverage, and upgrade readiness, then fix the riskiest issues first.
Should we use Odoo Studio instead?
For fields, views, and simple automations, often yes. We'll tell you when Studio is enough and save you the development cost.
Do custom modules work on Odoo.sh and Odoo Online?
Odoo.sh and self-hosted instances support custom modules. Odoo Online (SaaS) doesn't allow custom Python modules, which is a common reason to move hosting.
Can you publish modules to the Odoo App Store?
Yes, for modules you want to share or sell, packaged with documentation and the store's requirements.
How do you estimate a custom module?
From the written specification, broken into models, views, logic, and tests. Unknowns are listed explicitly rather than hidden in padding.
Will custom modules make upgrades harder?
Some extra work is unavoidable, because each module must be ported to the new versionSource [2]. Clean, separate modules keep that work small and predictable.
Do you modify Odoo's core code?
No. We extend Odoo through separate modules using its inheritance mechanisms, so standard updates keep workingSource [1].