Case study
How a growing Odoo team keeps 20+ instances up without a dedicated ops team
Inside a growing Odoo portfolio that spreads production across servers with a high-availability cluster, and the gap in monitoring worth closing.
CICDoo Team 5 min read
In short
A team running several dozen Odoo instances keeps production online across multiple servers with a high-availability cluster, rather than a single box and a prayer. The setup shows what a lean team can run without a dedicated ops function, and where monitoring is worth tightening next.
On this page
A portfolio that outgrew one server
A team running several Odoo projects on CICDoo has been a customer for 6 to 12 months. Between 6 and 20 projects, more than 20 instances across them, and 6 to 20 of those instances in production, spread across 6 to 20 servers. The code spans Odoo 13 through 20, Community and Enterprise, all on GitHub.
That is a familiar shape. A business starts with one Odoo instance, then a second for another entity or region, then a staging copy, then someone adds a long-lived branch for a project that never quite ships. A year in, nobody remembers which server runs what, and the thing everyone worries about is the one production instance that cannot go down during business hours.
The interesting part of this account is not the number of projects. It is how production is spread out, and what still needs attention.
Spreading production across servers
Among this team's features is a high-availability cluster: a primary project that runs the database, plus app nodes or replicas that serve the same site from other servers. The idea is simple. One project is the primary, its production instance owns the database, and the database is reachable only by that primary and the nodes attached to it. App nodes are separate projects, each pinned to a different production server, running the same repository, branch, Odoo version and edition as the primary, but with no database of their own; they serve Odoo against the primary's database instead. Point your domain at the cluster, and CICDoo checks every node every few minutes, routing visitors away from any node that stops answering.
An app node alone makes the Odoo application layer redundant: lose one server and the others keep serving. The database itself still lives on the primary's server, which is why a replica matters, an app node that also keeps a live standby copy of the primary's database, ready to be promoted if the primary's server is lost entirely. Promotion is never automatic. It is a deliberate action from the replica's settings, because the team running the cluster should decide when to accept the handful of seconds of changes that might not have replicated yet, not have that decision made for them at 3am.
None of this requires a platform engineer on staff. It requires picking which project is the primary, pointing the app nodes at it, and making sure every node in the cluster shares the same filestore, so an upload on one node is visible from all of them.
Promoting work without surprises
With 6 to 20 production instances and more than 20 instances overall, this team pushed 201 to 1000 upgrades and merges through CICDoo in the last 180 days, and 95 percent of them succeeded outright. At that volume, the deploy pipeline is not a side task, it is the daily rhythm.
The pattern CICDoo is built around is development, staging, production as three stages of the same project, each able to sit on its own server. Work lands on a development branch, gets merged forward into staging for a closer-to-production check, then merged again into the branch production actually runs. Each merge is a push to the target branch under the hood, so the instance running that branch deploys it the same way it would deploy any commit, through the project's existing GitHub webhook.
A 95 percent first-time success rate across hundreds of merges is a reasonable number to expect from that flow, not a remarkable one, provided the remaining 5 percent actually gets looked at rather than retried blindly. A merge conflict or a failed deployment leaves a readable log in the project's Queue tab naming exactly what happened, and the fix is to resolve the conflict in git, or address whatever the deployment log says, and merge again, not to guess.
On an app node specifically, pushing to its branch does nothing by itself. Updates to a cluster are always deployed through the primary, which stops each app node, updates the primary including any module upgrade, then starts the nodes again on the new code. That ordering matters more as the cluster grows: it is one more reason the primary's branch, not the individual nodes, is the one everyone pushes to.
Backups, restores, and the monitoring gap
In the same 180 days, this team took 1 to 10 backups and ran 1 to 10 restores, and had 51 to 200 automatic or manual restarts across their instances. Backups and restores at that volume suggest routine use, periodic checkpoints and the occasional restore to recover from a bad change or refresh a staging copy, rather than a crisis every week. On a high-availability cluster, backups are taken from the primary project only, since that is the only place the database actually lives; app nodes and replicas do not have their own Backups tab for exactly that reason.
The one place this account has room to tighten up is monitoring. Across their production fleet, the 30-day uptime figure comes back as not monitored, which means external uptime checks are not turned on everywhere production actually runs. A high-availability cluster is specifically designed to survive one server going dark without visitors noticing, but that resilience is easiest to trust when every production instance, primary, app node and replica alike, has its own uptime and response-time monitoring switched on, so a degraded node shows up on a chart before a customer notices anything.
What you can copy
- If one production instance is a single point of failure for your business, a primary plus one app node is the smallest useful high-availability cluster, and it is still just two projects pointed at the same code.
- Keep development, staging and production as separate stages of the same project, and move code forward with a merge rather than a fresh deploy to each one by hand, so every promotion goes through the same webhook-driven path.
- Read the deployment log on anything that fails instead of just retrying. At real volume, a consistent 95 percent first-time success rate is healthy; it only stays healthy if the other 5 percent gets diagnosed.
- Turn on monitoring for every production instance in a cluster, not only the primary, since the whole point of the cluster is that any node can be the one serving a visitor at a given moment.