Branching and reviews
A simple branching model, required reviews, and protected main branches.
Every change built, tested, scanned, and deployed the same way, with preview environments for review and a rollback that takes seconds.
$ anvexis tldr
Merge to main, watch it ship, roll back with one command if needed.
$ anvexis facts
name: ci
on: [pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with: { node-version: 22, cache: npm }
- run: npm ci
- run: npm run typecheck
- run: npm test
- run: npm run buildStage 01
Lint, typecheck, tests, and security scans run automatically.
Stage 02
A temporary environment for reviewers and stakeholders.
Stage 03
Main builds a versioned, immutable artifact.
Stage 04
Rolling or blue/green release with health checks.
Stage 05
Smoke tests and metrics confirm the release; rollback if not.
When deployments are manual, they are rare, stressful, and risky. Someone logs into a server, pulls code, restarts services, and hopes nothing breaks. Changes pile up between releases, so each release carries more risk, which makes the next one even scarier.
Continuous integration and delivery break that cycle. Every change is built, tested, and scanned automatically. Releases become small and frequent, each one easy to understand and easy to roll back. The pipeline becomes the one way code reaches production, so the process is the same every time, whoever is on duty.
For Odoo projects, a good pipeline also runs module tests, checks that data migrations work on a copy of production, and catches upgrade-breaking changes before they reach users.
| Stage | Checks | Catches |
|---|---|---|
| Lint and format | Style, static analysis, type checks | Obvious mistakes before review |
| Unit and module tests | Automated tests, including Odoo module tests | Broken logic |
| Security scan | Dependencies, images, secrets in code | Known vulnerabilities and leaked keys |
| Build | Versioned, reproducible image | Environment drift |
| Staging deploy | Migrations on production-like data | Upgrade and data issues |
| Production deploy | Gradual rollout with health checks | Problems that only show under real traffic |
A simple branching model, required reviews, and protected main branches.
GitHub Actions, GitLab CI, or your existing tool, versioned with the application.
Temporary environments per pull request so changes can be tested before merging.
Rolling or blue-green deployments with automatic health checks.
One command or one click to return to the previous version.
Deployment frequency, lead time, change failure rate, and time to restore.
Stage 01
Document how code reaches production today, including the manual steps.
Stage 02
Reproducible builds and tests on every pull request.
Stage 03
Deploy every merge to staging automatically.
Stage 04
Add approvals where needed and deploy through the pipeline only.
Stage 05
Track delivery metrics and remove the slowest steps.
Myth: Continuous delivery means deploying without control.
Reality: Pipelines can require approvals, run only in maintenance windows, and deploy to a subset first. Control is built in.
Myth: You need full test coverage before you start.
Reality: Start with the build and a few critical tests. Coverage grows as the pipeline proves its value.
Myth: CI/CD is only for big teams.
Reality: Small teams benefit most, because nobody has time for manual releases and late-night fixes.
The first pitfall is a pipeline that takes too long. When feedback arrives an hour after a push, developers stop waiting for it, so we cache dependencies, run tests in parallel, and keep the critical path short.
The second is a pipeline that's allowed to be bypassed. If urgent fixes still go straight to the server by hand, the pipeline loses its value, so we make the pipeline the fastest way to ship as well as the safest.
The third is ignoring the database. Application code rolls back easily; schema and data migrations need their own design so a release can be reverted without losing data.
| Measure | Why it matters |
|---|---|
| Deployment frequency | How often value reaches users |
| Lead time for changes | From merge to running in production |
| Change failure rate | Share of releases that need a fix or rollback |
| Time to restore | How quickly a failed change is undone |
Take a team of four developers maintaining custom Odoo modules, releasing once a month on a Saturday night. A pipeline now runs tests and linting on every pull request, deploys every merge to a staging environment with a recent copy of data, and promotes to production with one approval.
Releases become small and frequent, problems are caught in staging, and a bad release is rolled back in minutes. The team tracks deployment frequency and failure rate to see the improvement.
Success is a team that ships small changes several times a week without stress, catches problems in staging, and can undo a bad release in minutes. Delivery metrics show steady improvement, and nobody needs to remember the deployment steps.
DORA measures software delivery with five metrics: change lead time, deployment frequency, failed deployment recovery time, change fail rate, and deployment rework rateSource [1]. We baseline them before introducing CI/CD and track them after, so improvement is visible rather than claimed.
Pipelines hold the keys to production, so they need hardening. GitHub's security guidance says sensitive data should never be stored as plain text in workflow files, the GITHUB_TOKEN should have the minimum required permissions, and actions should be pinned to a commit SHASource [2]. We apply the same rules on any CI platform.
QA & test automation
Automated testing for web, mobile, APIs, and Odoo: unit, integration, end-to-end, and visual tests running on every pull request.
DevOpsDocker & Kubernetes
Containerize Odoo and services with Docker, then orchestrate with Kubernetes when it's warranted: health checks, autoscaling, and rollouts.
DevOpsMonitoring & SecOps
Prometheus and Grafana monitoring, centralized logs, alerting that respects sleep, and security hardening for servers and apps.
Next step
Thirty minutes with an engineer, no slide deck required. You'll leave with a clearer picture, whether or not we work together.