Skip to Content

Before You Customize Odoo: 7 Questions a Functional Consultant Should Ask First

Customization is sometimes the right answer, but only after you've asked the right questions.
November 17, 2026 by
Before You Customize Odoo: 7 Questions a Functional Consultant Should Ask First
Randy Charleston

Every Odoo customization starts the same way: someone has a problem, and they want the system to solve it. Maybe a warehouse manager needs a specific field on a delivery order. Maybe an operations team wants an automated step that Odoo doesn't do out of the box. Maybe a salesperson is asking for a button that doesn't exist yet.

The request itself isn't the problem. The problem is when a consultant treats every request as a development ticket and starts writing code before understanding what's actually being asked for and why.

I've seen plenty of Odoo implementations where customizations were built quickly, delivered on time, and caused headaches for years afterward. The code did exactly what was requested. It just didn't solve the underlying problem, or it created new ones. Before any development begins, a good functional consultant should be asking hard questions , not to slow things down, but to make sure the solution that gets built is actually worth building.

1. What problem are we actually trying to solve?

This sounds obvious, but it's the question most often skipped. A user says "I need a field that tracks X" or "I need a report that shows Y." The request is framed as a solution, not a problem. The consultant's first job is to step back and ask: what's happening today that makes this necessary?

Sometimes the answer reveals that the real issue is a process problem, not a system problem. Someone is tracking something manually in a spreadsheet because they never knew Odoo already had a place for it. Sometimes the answer confirms that a genuine gap exists and customization makes sense. Either way, you can't make that determination without understanding the underlying problem first.

When I start this conversation with a client, I usually ask: "Walk me through what actually happens today, step by step." That walkthrough almost always surfaces something the original request didn't capture.

2. What does success look like after the change?

Once you understand the problem, you need to understand what a good outcome looks like specifically, not generally. "Better reporting" isn't a success criterion. "The purchasing manager can see open PO lines by vendor without exporting to Excel" is a success criterion.

Getting specific about the desired outcome does two things. First, it helps you evaluate whether a proposed solution actually addresses the need. Second, it gives you something concrete to test against when the work is done. If you can't describe what success looks like before development starts, you are almost certainly going to end up with a change request after delivery.

It also opens up the conversation about whether there are multiple ways to reach that outcome and whether some of those ways are simpler than others.

3. Does standard Odoo already handle this?

This question requires genuine knowledge of the platform, and it's one of the places where an experienced functional consultant earns their keep. Odoo Enterprise covers a lot of ground, and features are added or improved with each version. Something that genuinely required a custom module in version 15 might be a standard configuration option in version 17.

Before reaching for custom development, it's worth thoroughly checking whether standard Odoo can do the job. That means looking beyond the obvious menus, checking technical settings, optional modules that may not be installed, reporting tools, analytic accounting configurations, and fields that exist but aren't visible in the default view layout.

I've had situations where a client was convinced they needed custom development for something that was already in Odoo, just two settings menus deep and turned off by default. That discovery saves real money and real maintenance overhead.

4. Can configuration solve this before code does?

There's an important distinction between customization and configuration. Configuration means working within Odoo's existing framework,  setting up workflows, adjusting views through the built-in editor, creating server actions or automated actions, defining approval rules, building custom filters and group-by options, or using the reporting engine. These are things any qualified Odoo administrator can set up and maintain without writing Python or modifying XML outside the interface.

Customization means extending or modifying Odoo's underlying code, new models, overridden methods, custom views written outside the interface, third-party Odoo apps.

Configuration solutions are generally faster to deliver, easier to document, easier to hand off, and much easier to carry forward during an upgrade. When configuration can cleanly solve the problem, it is almost always the better choice. The question is whether it actually solves the problem cleanly, not whether it technically produces some version of the desired result while creating confusion for the users who have to live with it.

5. Who will use this process, and how often?

The people using a process matter as much as the process itself. A workflow that makes perfect sense to a power user who understands Odoo's data model can be completely disorienting to a warehouse operator who logs in twice a day to confirm picks. A custom view that gives an analyst everything they need might be overkill for a manager who just wants a number on a dashboard.

Before recommending a solution, I want to know who is doing this task, how frequently, and what their comfort level with Odoo is. That shapes everything: how a form should be laid out, whether an automated action is better than a manual step, whether a simplified view makes more sense than exposing the full record.

It also surfaces questions about access rights and record rules. Who should be able to see this data? Who should be able to edit it? Who should not? These aren't afterthoughts, they're part of the design, and getting them right usually affects the implementation approach.

6. What are the exceptions?

Every business process has exceptions. The standard case is what people describe when you ask how something works. The exceptions are what you discover after the solution is built and the edge cases start appearing.

Asking about exceptions early is not pessimism, it's design discipline. If 90 percent of orders follow the standard path but 10 percent have a different approval requirement, that 10 percent needs to be accounted for before the solution is built, not retrofitted afterward. If a rule applies to all customers except the handful on custom pricing arrangements, that exception shapes the implementation.

Sometimes exceptions reveal that a requested customization is actually trying to handle a process that Odoo's standard workflow manages well, if the business is willing to adjust the exception handling slightly. That's a conversation worth having before anyone starts building.

7. What happens to this solution when Odoo is upgraded?

This question gets skipped constantly, and it's the one that creates the most regret.

Every piece of custom code is something that has to be reviewed, tested, and potentially rewritten when Odoo is upgraded. The more invasive the customization , overriding core methods, patching standard views, adding fields to heavily-used models,  the higher the upgrade cost and the higher the risk of something breaking. Some customizations are worth that cost. Many are not.

Before recommending custom development, a functional consultant should be able to answer honestly: how difficult will this be to maintain over the next few years? Is there a reasonable chance Odoo adds this natively in the next version or two? Is the business impact significant enough to justify the ongoing maintenance overhead?

This is not an argument against customization. It's an argument for treating customization as a deliberate choice with known costs, rather than a default response to every gap. When we prototype a solution and walk through it with a client before committing to the full build, this conversation happens naturally, both sides can see what's being built and have a real discussion about whether the tradeoff makes sense.

The point isn't to avoid customization, it's to earn it

None of these questions are obstacles to development. They are the work that makes development worth doing. A functional consultant who jumps straight to writing requirements without working through these questions is likely to deliver something technically correct that misses the mark operationally, or that creates problems six months later when no one can remember why a particular piece of code exists.

Customization is sometimes exactly the right answer. There are requirements that standard Odoo genuinely cannot meet, processes that are central enough to a business's competitive advantage that they are worth the long-term maintenance investment, and situations where a well-built custom module is cleaner and more maintainable than a tangle of workarounds in standard functionality. When customization is the right answer, these questions help you build the right thing. When it isn't, they help you find the better path before anyone has spent time and money on the wrong one.

The goal is not to minimize the number of customizations. The goal is to make sure every customization that gets built is one that actually needed to exist.


If you have a customization request on the table and you're not sure whether development is really the right move, that conversation is worth having with someone who understands both the business process side and the Odoo platform before the first line of code gets written. DimeSoft has been working through exactly these questions with clients across distribution, manufacturing, and e-commerce for a long time. If you want a candid second opinion — not a pitch — reach out and we'll talk it through.

How We Run an Odoo Project: The Case for Iterative Delivery
The ERP project that ships exactly what the client originally specified is, more often than not, the wrong project. Here's how we close that gap on purpose.