Knowledge Hub · Pillar guide
Complete Guide to Odoo Development
How professional Odoo software is built — module architecture, ORM, views, security, APIs, testing, deployment, and long-term maintenance for technical leads and delivery teams.
~20 min orientation · 12 supporting articles · Last reviewed 2026-07-30
Table of contents
- Executive summary
- What Is Odoo Development?
- Odoo Architecture Overview
- Odoo Module Structure
- ORM Fundamentals
- Models and Business Logic
- Views and User Interface
- Security and Access Rights
- Server Actions and Automation
- Scheduled Jobs
- APIs and Integrations
- Performance Considerations
- Testing
- Deployment
- Upgrade Strategy
- Code Quality
- Documentation
- Long-Term Maintenance
- Supporting articles
Odoo development is the engineering craft of building and maintaining addons: models, views, security, jobs, and integrations that run in production for years. This pillar explains how that work is done — not whether you should customize (covered in the Customization guide).
Each section introduces a topic and links to a dedicated article. Use the pillar for orientation; open articles when you need implementation depth for ORM, security, testing, or deployment.
Services and portfolio links appear where they help you evaluate delivery capacity. The educational path stays first: architecture → code quality → operate and upgrade.
Trigger
Business event starts the flow.
Execute
Operate in the system of record.
Validate
Check outcomes and exceptions.
Close
Reconcile and hand off.
Request
HTTP / RPC enters Odoo.
Auth & ACL
Users, groups, record rules.
ORM work
Reads/writes with business logic.
Response
UI, API payload, or job enqueue.
- Owners named
- UAT scripts signed
- Rollback documented
- Hypercare roster ready
01
Development means shipping versioned addons with clear ownership — Python models, XML UI, security CSV, tests, and deploy notes — not one-off database edits.
Read: What Is Odoo Development? →02
Requests hit HTTP, registry, ORM, and PostgreSQL. Understanding that path explains why heavy work belongs in models, jobs, or workers — not in form onchange storms.
- ▸Addons load into the registry at startup / module upgrade
- ▸Business logic lives on models; controllers expose HTTP
- ▸PostgreSQL is the source of truth; caches are helpers
Client / Channel
Users & devices
Odoo Application
Business logic
PostgreSQL
System of record
Workers / Cron
Async work
- clientapp(HTTP)
- appdb(ORM)
- appjobs(queue)
03
A module is a package with `__manifest__.py`, models, views, security, and data. Naming, dependencies, and file layout decide how painful upgrades become.
Read: Understanding Odoo Module Structure →__manifest__.py
models/
views/
security/
data/
- manifestmodels
- modelsviews
- modelssec
04
The ORM maps models to tables, batches reads/writes, and runs recordsets through the environment. Misusing it is the root of most performance bugs.
Read: How the Odoo ORM Works →Model
Python class
Fields
Stored / computed
SQL table
Persistence
Cache / prefetch
Performance
- modelfields
- fieldstable
- modelcache(prefetch)
05
Fields, relations, computes, constraints, and overrides encode process. Prefer inheritance and explicit methods over silent core monkey-patches.
Read: Models, Fields, and Relationships →06
Form, list, search, and kanban views plus menus and actions define the operator experience. Stable XML IDs and surgical XPath keep UI upgrades calm.
Read: Views, Menus, and Actions →07
ACLs and record rules enforce authorization on the server. Hiding a button is not security. Multi-company fields need deliberate rules.
Read: Security: Groups and Record Rules →Authenticate
User session or API key.
Groups
Feature access.
Record rules
Row-level visibility.
Field access
Read/write restrictions.
08
Server actions and automated actions are useful for light ops — and dangerous when they replace tested Python. Know when to promote them into modules.
Read: Scheduled Actions and Cron Jobs →09
Cron jobs must be idempotent, chunked, and observable. Long jobs belong in queues or split batches, not a single multi-hour transaction.
Read: Scheduled Actions and Cron Jobs →10
XML-RPC, JSON-2, and custom controllers connect Odoo to Shopify, WMS, or middleware. Design for auth, retries, and idempotent writes.
Read: REST APIs and External Integrations →11
Prefetch, avoid N+1, index filters you search, and keep computed stored fields intentional. Profile on staging with production-like data volumes.
- ▸Batch writes and use mapped/filtered carefully
- ▸Watch search domains that cannot use indexes
- ▸Move heavy sync off the request path
12
TransactionCase and HttpCase catch money, stock, and access regressions before users do. Tests are part of the module, not a post-go-live wish.
Read: Testing Odoo Modules →13
Promote through staging with `-u`, backups, and a written rollback. Odoo.sh, Docker, and bare metal differ — the checklist does not.
Read: Deployment Best Practices →Git → CI tests → staging upgrade → prod cutover.
Build
CI installs deps and runs tests.
Stage
Deploy to staging with prod-like data.
Approve
UAT and change board.
Promote
Production deploy with rollback ready.
14
Upgrade-friendly code inherits, migrates data deliberately, and re-runs tests on the target version before cutover.
Read: Writing Upgrade-Friendly Code →15
Small PRs, linting, review checklists, and clear module boundaries beat heroics. Treat addons as a product, not a dump of tickets.
Read: Maintaining Large Odoo Projects →Core modules
Stable APIs
Industry modules
Vertical logic
Integration glue
Connectors
UI extensions
Views & wizards
- coreind
- coreglue
- indui
16
Operators need runbooks; developers need decision records and dependency inventories. Undocumented modules become rescue projects.
Read: Maintaining Large Odoo Projects →17
Large Odoo estates need ownership, regression suites, upgrade calendars, and a support path — not only feature velocity.
Read: Maintaining Large Odoo Projects →- Owners named
- UAT scripts signed
- Rollback documented
- Hypercare roster ready
Supporting articles
Independent deep-dives in this development cluster.
intro · 8 min
What Is Odoo Development?
A practical definition of professional Odoo development: modules, ownership, workflow, and how it differs from customization strategy and external Python services.
intro · 10 min
Understanding Odoo Module Structure
How Odoo addons are laid out: manifests, models, views, security, data, and dependency order — the foundation every developer ticket should respect.
intermediate · 12 min
How the Odoo ORM Works
Environments, recordsets, transactions, prefetch, and the create/write/unlink lifecycle — practical ORM behavior for Odoo 16/17 developers.
intermediate · 13 min
Models, Fields, and Relationships
Designing Odoo models: field types, Many2one/One2many/Many2many, inheritance modes, constraints, and schema decisions that survive reporting and upgrades.
intermediate · 11 min
Views, Menus, and Actions
Building and inheriting Odoo UI: form, list, kanban, search views, xpath, window actions, menus, and client-side patterns for Odoo 16/17.
intermediate · 12 min
Security: Groups and Record Rules
Odoo access rights: ir.model.access.csv, security groups, record rules, field-level restrictions, and multi-company patterns that enforce server-side.
intermediate · 10 min
Scheduled Actions and Cron Jobs
Designing reliable Odoo cron jobs: ir.cron configuration, idempotency, batching, failure handling, and alternatives to infinite server actions.
advanced · 14 min
REST APIs and External Integrations
Integrating Odoo with external systems: JSON-RPC/XML-RPC, REST controllers, webhooks, API keys, idempotent sync, and when to build middleware outside Odoo.
advanced · 13 min
Writing Upgrade-Friendly Code
Engineering patterns that survive Odoo version upgrades: inheritance over fork, xpath stability, migration scripts, noupdate data, and avoiding private API coupling.
intermediate · 11 min
Testing Odoo Modules
Automated testing for Odoo addons: TransactionCase, SavepointCase, test tags, mocking RPC, view loading checks, and CI patterns for Odoo 16/17.
intermediate · 12 min
Deployment Best Practices
Shipping Odoo modules safely: staging parity, -u vs -i, backups, zero-downtime limits, workers, logging, and rollback playbooks for on-prem and Odoo.sh.
advanced · 14 min
Maintaining Large Odoo Projects
Governance for multi-module Odoo estates: ownership, branching, dependency maps, technical debt triage, documentation, and sustaining teams after go-live.
Related services
Odoo Delivery
Implementation and custom module programmes with upgrade-minded delivery.
View →Dedicated Odoo Developer
Reserved engineering capacity for modules, reviews, and backlog.
View →Python Development
Python services beside Odoo — APIs, workers, and backend systems.
View →Odoo Support
AMC and maintenance for live Odoo systems with custom addons.
View →Related portfolio
Furniture quote-to-subcontract
Custom workflow modules for configurable manufacturing.
View →POS fiscal play-center
Operational modules plus hardware middleware integration.
View →Shopify–Odoo integration
External API sync and product automation beside Odoo.
View →Shadow Group multi-company migration
Large customized codebase sustained through a major upgrade.
View →Need Odoo development capacity?
Share your edition, hosting (Odoo.sh / on-prem), and whether you need a project, dedicated developer, support, or rescue.
