Skip to content
Back to achievements

Achievements

Business module development for an ERP

Solo design of 16 Odoo modules from scratch, plus fixes, improvements, and migration work on third-party modules.

Achievement summary

This summary provides the essential reading points. It does not replace the complete case study: scroll down to review the detailed context, steps, limitations, and critical review.

Context
At 1UP Distribution, accounting, sales, sales administration, and logistics needs exceeded Odoo's no-code customization capabilities.
Challenge
Turn cross-functional needs not covered by no-code configuration into reliable, maintainable ERP extensions.
My role
I independently designed 16 Odoo modules, from requirements analysis through development, testing, deployment, and user support.
Key decision
Group changes into a versioned, testable module layer tied to processes instead of multiplying isolated customizations.
Result
The modules automate business tasks, structure shared data, and make functions such as reminders, documents, and B2B synchronization manageable within the ERP.
Evidence
Screenshots and publishable generic modules illustrate the work, while internal material remains subject to authorization and anonymization.View the detailed evidence

Visual proof

Screenshots and demos from real projects.

List of custom business modules

List of custom business modules

Overview of Odoo modules built to cover accounting, sales, logistics, and B2B needs.

View the full-size screenshot

01

Presentation

At 1UP Distribution, accounting, sales and logistics had requirements that standard Odoo configuration did not cover well. I designed and maintained sixteen in-house modules, from understanding the requests to supporting users after deployment. They cover customer payment reminders, packing documents and invoice margin reporting, among other workflows.

A deliberate boundary between configuration, Studio, and version-controlled code. My decision rule starts by checking whether Odoo already provides the required configuration. When it does, I use it and do not develop a second solution. If the requirement needs customization, I then assess what Studio would store in the database. Modifying a view with Studio, for example, creates an inherited view and an XPath expression that targets the modified area. For long-term company adaptations, I prefer declaring this inheritance in a module and versioning it in the GitHub repository. Version control preserves change history, makes differences reviewable, reproduces the customization across environments, and simplifies analysis during migration. This choice requires more discipline during development but is considerably more maintainable than accumulating technical changes scattered throughout the database.

Overdue invoice reminders illustrate the full lifecycle. Accounting needed to identify overdue invoices and apply rules that varied by situation. I organized those rules in a version-controlled module with settings accessible to the people responsible for follow-up.

The 1up_specifique module for QWeb reports. This module notably centralizes PDF document adaptations used in the Sales, Accounting, and Inventory applications. Odoo produces these documents with QWeb, a templating engine that combines an HTML/XML structure with ERP data before generating the PDF. The documents include pro forma invoices and delivery slips. A pro forma invoice is a preliminary commercial document presenting the terms of a sale before the final accounting invoice. A delivery slip describes the products handed over or shipped to the customer. Standard reports did not include all the information required by customers or internal teams. I therefore added the appropriate fields, display conditions, and layouts so that printed documents became genuinely usable in daily operations.

02

Objectives, context and stakes

Accounting needed to identify and follow up on invoices under the company’s rules. Staff needed to adjust timing, recipients and exclusions as the process changed, and to understand the module’s decisions when checking them.

Prioritizing by impact rather than arrival order. Requests from several departments could not all be developed immediately. I assessed their priority using four main criteria — whether the problem was blocking, how much time the current situation wasted, whether it represented a quick win, and its financial impact. A quick win is an improvement that is fast to implement relative to the benefit it provides. A short request could therefore take priority over a larger project if it immediately removed a significant repetitive task. Conversely, a problem that prevented a department from working or caused financial loss became a priority even if its resolution was more complex. This method connected development order to expected company value rather than only to the request date.

03

Risks and mitigation measures

An incorrect reminder can reach an excluded customer or go out at the wrong time. The risk came from business exceptions as well as code because users knew some conditions that had never been written down. I separated changeable rules from the Python logic to make them easier to review and adjust.

Disclosure of confidential data. The most sensitive risk involved access rights. A salesperson once asked me for access to their customers' invoices as well as the Purchase application. An invoice can contain prices, commercial terms, contact details, and other information that should not be open to every user. The Purchase application also provides access to the company's supplier and cost data. Because Odoo rights combine through groups and can be refined through record rules, an overly broad permission could expose far more data than the request required. I therefore obtained approval from my direct manager before implementing access strictly limited to the scope authorized by management.

Degraded ERP performance. A custom module runs in the same application as standard Odoo functions. An overly broad search, an unnecessarily repeated calculation, or an automation triggered across a large number of records could slow a screen, scheduled task, or the entire server. This risk increases when processing appears fast on a small test dataset but later has to scan production volume. I therefore needed to verify functional behavior while remaining attentive to the number of records processed, execution frequency, and database operations. A correct but overly expensive feature would degrade every user's experience.

04

The steps — what I did

Formalizing the requirement in Jira. I transcribed the explanations into a Jira ticket, meaning a tracking record that centralizes the problem, the work to perform, and its progress. I added subtasks to break down development, the test processes to reproduce, and acceptance criteria. An acceptance criterion describes an observable outcome that must be verified before a feature can be considered compliant. This formalization served as a reference during development and reduced the risk of forgetting an exception mentioned verbally. It also allowed accounting to compare the delivered behavior with what had been agreed.

Turning accounting rules into verifiable parameters. I listed the information that determines whether a reminder should be triggered — payment terms, customer type, the bank account receiving payment, and the options defined by accounting. Payment terms establish the date or dates on which an invoice becomes due and therefore make it possible to calculate the number of overdue days. General configuration notably defines reminder intervals, email templates, and the invoice report to attach. Customer-specific settings complete these rules — additional recipients, explicit exclusion from reminders, an invoice assigned to factoring, or use of a bank account requiring different treatment. This inventory formed the module's functional decision matrix.

An initial internal notification. The first job ran daily, checking overdue invoices and notifying accounting and the sales representative about relevant cases. Staff could verify which invoices were selected before customer reminders were added. Their feedback clarified the exceptions, reminder stages and settings they needed to control.

Evolving the module into a reminder system controlled from the ERP. Usage feedback showed that the logic needed to be more configurable and go beyond an internal notification. I therefore evolved the module so that accounting could determine directly in Odoo who should be notified, which intervals should apply, which email template should be used, and which invoice document should be attached. It can also define after how many days a customer should be blocked, preventing certain operations from continuing normally when the delay becomes too significant. Most of these values had previously been hardcoded, meaning that every change required a code update and a new deployment. Moving them into ERP settings made the behavior adaptable by authorized users without technical intervention for every rule change.

Testing a matrix of cases in staging. I checked the different branches of the process in preproduction — an invoice that had not yet reached its due date, an invoice matching each reminder stage, an explicitly ignored customer, an invoice covered by factoring, a specific receiving bank account, additional recipients, the selected email template, the expected attachment, and the blocking threshold. Staging is an isolated copy used to test new code with representative data without modifying production. Odoo.sh neutralizes outgoing email there and intercepts it with a mail catcher. This tool makes it possible to inspect the recipient, subject, content, and attachments exactly as if the message had been sent, while preventing a real customer from receiving a test reminder.

Deploying through the Odoo.sh staging-to-production flow. Once the staging build completed without errors, testing was finished, and business validation had been obtained, the staging branch was merged into the production branch. Odoo.sh then started a rebuild — the platform reconstructed the environment with the new Git repository revision, restarted Odoo, and updated the code running in production. When required by the module version or a data transformation, the associated migration scripts were also executed. This process makes deployment reproducible — production receives version-controlled, tested code rather than a sequence of manual changes that cannot be traced.

05

The stakeholders — interactions

Accounting described the reminder process, decided how exceptions should be handled and checked the result in staging. My manager approved release after the trials and demonstration. I owned the technical choices, documentation and training. Decisions affecting customer relationships were discussed with the staff responsible for them.

Depending on the module, I worked with sales, sales administration, logistics or management. Their examples helped turn broad requests into verifiable criteria, such as whether a packing document showed the information a logistics operator expected.

Seeking a compromise when the exact request was impossible. Sometimes a requirement could not be implemented exactly as the user imagined because of a technical Odoo constraint. In that situation, I did not attempt to hide the gap. I explained what prevented the initial solution, the difference between the desired result and the actual possibilities, and then proposed the alternative that best addressed the objective. The discussion therefore focused on the problem to solve rather than on a solution format that had become unfeasible. This transparency avoided creating an expectation the module could not meet.

06

The results

The scheduled action handles routine reminders in production. Accounting can change the main settings without requesting a code change. This gives the team a more regular process while keeping the rules under its control. The impact on payment delays and time spent on reminders remains to be measured.

Human control retained for factoring. Automation does not remove every accounting check. Invoices for customers covered by factoring notably continue to require special attention. Under this arrangement, a receivable may be assigned to a financial institution involved in financing or collection. A reminder sent directly by the company may then conflict with the expected process. The result sought was therefore not to eliminate human intervention, but to focus it on exceptions while standard cases are handled automatically.

An incorrect reminder. An invoice subject to factoring triggered a reminder because the customer was not marked as such in the ERP. The module followed the rule for the available data, but the settings did not reflect the actual process. This case showed me that acceptance testing also needs to cover the data governing a rule. It reinforced the value of showing users which settings to review before sending reminders.

PDFs populated from ERP data. I adapted the QWeb reports to include taxes and transport information, along with logistics instructions or special delivery conditions where relevant. Staff could find information already entered in Odoo on the PDF. I did not measure changes in preparation time or the number of clarification requests.

An indicator available during the financial year. The margin module brings sales revenue together with the costs included under the company’s rules. The managing director can view the indicator on invoices during the year. Previously, the year-end close and the accountant’s analysis were the main reference points. The module gives management an interim view and still depends on validating the calculation method with accounting.

B2B synchronization enabled by custom API routes. The 1up_b2b_specifique module allows the B2B website to synchronize the data it needs correctly with Odoo. An API is an interface that lets two software systems exchange information according to defined rules. An API route is an entry point exposed by the server to read, create, or update specific data. Some operations required by the website were not available in Odoo's standard API. I therefore developed routes adapted to the company's process. The B2B site can obtain or transmit the expected information without bypassing the ERP or manually duplicating data.

07

After the project

Accounting can update timing and exclusions as needs change. Requests affecting calculations, permissions or a new reminder type go through a ticket, testing and further validation. Documentation and version control make those changes easier to take over.

Measuring the effect of reminders. At the time of the review I had no figures for time saved or changes in payment delays. I would compare periods with similar invoice volumes, recording eligible invoices, reminders sent, cases reviewed manually and time spent on follow-up. Payment delays could also change with customer mix or invoice amounts. The first goal of measurement would be to see where automation frees up time and where accounting staff still need to intervene.

08

My critical review

Early extensions encoded values that actually depended on team practices. As a result, a small rule change required a deployment. Moving those values into business settings improved maintainability and clarified which decisions belonged to users.

The 1up_specifique module as the refactoring priority. If I had to revisit one module first, I would choose 1up_specifique. It centralizes several report adaptations and still contains a few fixed values. Refactoring means reorganizing code without removing the functional value it already provides. Here, it would involve identifying company-specific values, deciding which should become settings, and leaving only document-generation logic in the code. The module would thereby become more readable, portable, and easier to migrate.

I would keep acceptance testing with accounting and write tests earlier for exclusions, due dates and permissions. On margin calculations, I repeatedly had to trace discrepancies back to their journal entries to understand the accounting rules. I would keep those cases as regression tests and also measure query costs on realistic data volumes before release.