What Is Odoo Runbot? Complete Beginner Guide & Tutorial 2026

Odoo Runbot automates testing and deployment for Odoo modules and custom developments. Understanding how it works helps developers ship code faster, catch bugs earlier, and maintain higher quality standards. This guide explains what Runbot is, how to set it up, and how to use it effectively—written for developers of all skill levels.

For UAE Odoo Developers & Partners: If you’re building custom Odoo modules, extending core functionality, or managing Odoo implementations in UAE, Saudi Arabia, or the Middle East, Runbot is essential infrastructure. It ensures your code changes don’t break existing features, helps you test across multiple Odoo versions, and automates deployment workflows. This guide is tailored for Odoo partners and development teams working in the UAE and GCC region.

You’re a developer asking: What exactly is Odoo Runbot? How do I set it up? What does it do? How do I interpret test results? Can I use it for my custom modules? This guide answers these questions with detailed explanations, step-by-step tutorials, and practical examples.

What Is Odoo Runbot? Complete Definition

Odoo Runbot definition: A continuous integration and continuous deployment (CI/CD) system designed specifically for Odoo development. Runbot automatically tests code changes, runs quality checks, and manages deployment workflows whenever developers push code to a repository.

The Simple Explanation

Imagine you’re developing a custom Odoo module. You write code, test it locally, and push it to GitHub. Instead of manually running tests on every Odoo version, manually checking for code quality issues, and manually deploying—Runbot does all of this automatically.

Here’s what happens in the background:

• You push code to GitHub
• Runbot detects the change automatically
• Runbot creates a fresh Odoo database
• Runbot installs your module
• Runbot runs automated tests
• Runbot checks code quality
• Runbot creates a live test instance (if tests pass)
• You see results in the Runbot dashboard

All of this happens in minutes without any manual intervention. This is CI/CD automation for Odoo.

Why Should You Care About Runbot?

1. Catch Bugs Earlier: Automated testing detects issues before code reaches production. Instead of customers discovering bugs, Runbot finds them during development.

2. Save Development Time: No need to manually test across multiple Odoo versions. Runbot does this in parallel, potentially cutting testing time by 60-75%.

3. Maintain Code Quality: Runbot enforces code quality standards automatically. Every commit is checked for common issues, duplicated code, and style violations.

4. Easier Collaboration: Team members can see test results and understand whether a change is safe to merge. This is especially valuable for teams with multiple developers.

5. Reduce Production Incidents: With automated testing, fewer bugs reach production. This means fewer emergency fixes, fewer customer complaints, and more stable deployments.

Key Runbot Concepts (For Beginners)

Build: A single test run triggered by a code commit. Each build tests your code against a specific Odoo version and configuration.

Branch: A separate version of your code (usually in Git). Runbot can test multiple branches independently, so you can test different features in parallel.

Test Instance: A live Odoo environment created by Runbot where your module is installed and ready to explore. You can access this via web browser.

Status Badge: A visual indicator (green = pass, red = fail) that shows whether your build is successful. These appear on GitHub and in documentation.

Logs: Detailed records of everything Runbot did during testing—installation steps, test outputs, error messages. Essential for debugging failures.

How Odoo Runbot Works: The Technical Flow

Understanding the step-by-step process helps you troubleshoot problems and optimize your workflows.

The Runbot Workflow (Simplified)

1 GitHub Push Triggers Runbot

When you push code to GitHub, a webhook automatically notifies Runbot. Runbot immediately prepares to test your code.

2 Runbot Clones Your Repository

Runbot downloads your code from GitHub and prepares a clean environment for testing. No interference from previous tests.

3 Fresh Database Is Created

For each build, a brand-new Odoo database is created. This ensures consistent, isolated testing. No leftover data from previous tests.

4 Your Module Is Installed

Runbot installs your module into the fresh database. If installation fails, the test fails immediately. Installation errors are caught at this stage.

5 Automated Tests Execute

Runbot runs your Python test files (tests/test_*.py). These tests validate that your module works correctly. Failed tests show which features have issues.

6 Code Quality Analysis Happens

Tools like flake8, pylint, and other linters check your code against quality standards. Issues are flagged but don’t necessarily fail the build.

7 Test Instance Is Created

If all tests pass, Runbot creates a live Odoo environment where your module is running. You can access this browser and explore your module in action.

8 Results Are Displayed

Runbot displays test results on your GitHub pull request. You see pass/fail status, logs, and a link to the test instance.

Odoo Runbot Visual Guide: What You’ll See

Here are the key screens and dashboards you’ll encounter when using Runbot. Understanding what each element means helps you interpret results and troubleshoot issues.

1. Runbot Build Dashboard

Odoo Runbot Main Dashboard

What You See on the Odoo Runbot Dashboard

The Odoo Runbot dashboard is the primary interface for monitoring automated builds, continuous integration (CI) pipelines, and testing environments for Odoo ERP Software. It allows developers, Odoo partners, QA engineers, and contributors to validate code changes, review build results, launch test instances, and monitor development progress across multiple Odoo versions before deployment.

The dashboard provides a real-time overview of every active build and displays the following information:

• Branch Name – Identifies the development branch currently being tested, such as master, saas-19.4, saas-19.3, or saas-19.2.
• Build Status – Shows whether the build has passed, failed, or is currently running, allowing developers to identify issues quickly.
• Build Age – Displays when the build was created or last updated (for example, 5 minutes ago, 3 hours ago, or 12 hours ago).
• Automated Build Jobs – Lists the automated testing stages executed for each build, including Community Run, Enterprise Run, Design Themes, and Documentation.
• Quick Actions – Provides shortcuts to open a live test database, access build logs, restart a build, or view additional build settings.
• Testing Queue – Displays the number of builds that are currently pending or being tested, helping developers monitor CI workload in real time.
• Navigation Menu – Includes links to R&D, Industry, Tutorials, GitHub integration, user login, and the global search function.
• Continuous Integration Overview – Offers a live snapshot of automated testing activity across all supported Odoo branches, ensuring code quality before merging or deployment.

Why the Odoo Runbot Dashboard Is Important

The Odoo Runbot dashboard plays a critical role in the Odoo development workflow by providing instant visibility into build health, automated test results, and deployment readiness. It enables developers to detect issues early, verify new features, validate custom modules, and maintain stable Odoo ERP Software releases through continuous integration and automated quality assurance.

Whether you are testing a new customization, reviewing a pull request, or validating compatibility with different Odoo versions, the Runbot dashboard provides the information needed to streamline development, reduce errors, and improve release quality

2. Test Instance: Live Odoo Environment

Runbot Test Instance (Live Odoo)

Accessing Build Actions and Logs in Odoo Runbot

The Build Actions menu in Odoo Runbot provides developers with quick access to testing environments, build logs, database management, and email debugging tools. These options help troubleshoot build failures, validate deployments, inspect installation processes, and monitor automated testing without leaving the Runbot dashboard.

When you click the Actions (gear/menu) icon for a build, you’ll find the following options:

• Connect Base – Opens the live Odoo test instance, allowing developers to explore and validate the running application.
• Database Selector – Displays all databases created for the selected build, making it easy to switch between testing environments.
• Full Install Run Logs – Shows the complete installation and execution logs for the build, helping identify installation or runtime issues.
• Full Install Base Logs – Displays detailed logs related to the base Odoo installation process.
• Full Pre-Run Configuration Logs – Provides configuration logs generated before automated testing begins, making it easier to diagnose setup problems.
• Full Run Logs – Displays the complete execution logs for the entire build process, including automated tests, module installation, and system events.
• Mailhog – Opens the Mailhog interface to review emails generated during testing, allowing developers to verify email notifications, templates, and automated workflows.

How to Open an Odoo Runbot Test Instance

Follow these steps to access a live testing environment:

1. Open the Odoo Runbot dashboard.
2. Select the branch or build you want to test.
3. Wait until the build status changes to Passed.
4. Click Connect Base from the Build Actions menu.
5. The live Odoo ERP Software instance opens in a new browser tab.

Why Build Actions and Logs Are Important

The Build Actions menu is an essential debugging and development feature in Odoo Runbot. It enables developers to access live test environments, review installation logs, inspect automated test results, troubleshoot configuration issues, validate email functionality, and quickly resolve build failures. These tools streamline the Odoo ERP Software development workflow while supporting continuous integration (CI), automated testing, and quality assurance.

How to Log In to an Odoo Runbot Demo Instance

Step1: Open the Odoo Runbot dashboard.

Link to https://runbot.odoo.com/

Step2: Select a build with a Passed status.

Step3: Click Connect Base to launch the live Odoo instance.

Wait for the login page to load. after the loading and Select the available demo database if prompted.

Click Log In using the default demo credentials, or continue directly if the instance is already authenticated.

Nb: Some Runbot demo instances automatically log you in, while others display the standard Odoo login screen depending on the build configuration.

Default Odoo Runbot Demo Credentials

Most Odoo Runbot demo environments use the following credentials:

• Email: admin
• Password: admin

Some builds may use different credentials or automatically authenticate users without requiring a login.

What You Can Do After Logging In

After successfully logging in, you can:

• Explore all installed Odoo applications.
• Test standard business workflows.
• Create demo customers, products, and sales orders.
• Configure settings and install supported modules.
• Validate custom developments and integrations.
• Learn new features introduced in different Odoo versions.

Why the Odoo Runbot Demo Is Useful

The Odoo Runbot demo environment allows developers, consultants, and business users to experience Odoo ERP Software in a safe testing environment before implementation. It helps users evaluate new features, reproduce issues, test custom modules, and gain hands-on experience without affecting a live production database. This makes Runbot an essential learning and development resource for anyone working with Odoo ERP Software.

Getting Started with Odoo Runbot: Step-by-Step Setup

Here’s how to enable Runbot for your Odoo module or custom development.

Step 1: Create a GitHub Repository (If You Don’t Have One)

Runbot works by monitoring your GitHub repository. If you don’t already have a repository, create one:

• Go to github.com and sign in (or create a free account)
• Click “New repository” button
• Name your repository (e.g., “odoo_custom_module”)
• Add a description (optional)
• Choose “Public” (recommended for open-source)
• Click “Create repository”

You now have a GitHub repository. Copy the repository URL (looks like: https://github.com/yourname/odoo_custom_module.git)

Step 2: Prepare Your Module Structure

Your Odoo module must follow the standard directory structure for Runbot to recognize it:

my_module/ ├── __init__.py ├── __manifest__.py ├── models/ │ ├── __init__.py │ └── my_model.py ├── views/ │ └── my_view.xml ├── tests/ │ ├── __init__.py │ └── test_module.py └── README.md

Critical: The tests/ directory must exist (even if empty). Runbot looks for test files here.

Step 3: Create Test Files

Runbot requires at least one test file. Here’s a minimal example:

# tests/__init__.py # (can be empty) # tests/test_module.py from odoo.tests import TransactionCase class TestMyModule(TransactionCase): def test_module_loads(self): """Test that the module loads without errors""" model = self.env['ir.module.module'] self.assertTrue(model) def test_create_record(self): """Test creating a record""" record = self.env['my.model'].create({ 'name': 'Test Record', }) self.assertEqual(record.name, 'Test Record')

These tests verify: Module loads without import errors, Module can create records without errors, Basic functionality works as expected.

Step 4: Create .runbot.yml Configuration File

Add a .runbot.yml file to your repository root to configure Runbot behavior:

version: 2 jobs: test: machine: image: ubuntu-2204:current steps: – run: name: Install dependencies command: apt-get update && apt-get install -y python3-dev libpq-dev – checkout – run: name: Install Odoo requirements command: pip install -r requirements.txt

Step 5: Connect Your Repository to Runbot

Go to your Runbot instance and configure it to monitor your repository. Visit your Runbot dashboard and: Click “Repositories” or settings, Add your GitHub repository URL, Configure which branches to monitor (usually “main” and “develop”), Save configuration.

Step 6: Make Your First Commit

Push code to GitHub to trigger your first Runbot build:

git add . git commit -m “Initial Odoo module with Runbot setup” git push origin main

Within seconds, Runbot will detect the push and start building. You’ll see a notification in your GitHub repository showing the build status.

How to Use Odoo Runbot: Practical Workflows

Workflow 1: Check Test Results After a Pull Request

Scenario: You’ve created a pull request with new features. You want to verify that tests pass before merging.

1. Create your pull request on GitHub (describe your changes)
2. Runbot automatically detects the PR and starts testing
3. Within 2-4 hours, Runbot posts a status check on your PR
4. If status is green (✓ passed), your code changes don’t break anything
5. If status is red (✗ failed), click “Details” to see what went wrong
6. Fix the issues, commit again, and Runbot re-runs tests automatically
7. Once tests pass, you can safely merge the PR

Workflow 2: Explore Your Module in a Test Instance

Scenario: You want to manually test your new feature in a live Odoo environment.

1. Navigate to the Runbot build page for your code
2. Find the build with green (passed) status
3. Click the “Test Instance” link (looks like: http://runbot.example.com/build/12345)
4. You’re logged into a live Odoo environment with your module installed
5. Explore your module’s features, test workflows, verify UI
6. Create test records, navigate menus, validate functionality
7. When done, the instance is automatically deleted after 24-48 hours

Workflow 3: Debug a Failed Build

Scenario: Your build failed. You need to understand why and fix the issue.

1. Open the failed build on Runbot
2. Scroll down to “Logs” section
3. Read the logs carefully (start from the bottom where the error occurred)
4. Look for error messages like “ImportError”, “AttributeError”, “AssertionError”
5. Note the exact line where the error occurred (e.g., “test_module.py:42”)
6. Open your code and look at that line
7. Fix the issue (common issues: missing import, typo in method name, missing dependency)
8. Commit and push again
9. Runbot re-runs tests automatically

Common Runbot Issues & How to Fix Them

Issue 1: “ModuleNotFoundError: No module named ‘my_module'”

What it means: Runbot can’t find your module. Usually means your repository structure is wrong.

How to fix: Verify your module directory contains a __manifest__.py file. The module directory name should match your module name (e.g., my_module/__manifest__.py).

Issue 2: “ImportError: cannot import name ‘fields’ from ‘odoo'”

What it means: Your code imports a module that doesn’t exist in the Odoo version being tested.

How to fix: Check your imports. Ensure you’re importing from correct Odoo packages. For version-specific code, use conditional imports.

Issue 3: “Tests passed but test instance link is broken”

What it means: The test instance was created but is no longer accessible.

How to fix: Test instances expire after 24-48 hours. If you need to re-test, create a new build by committing new code or creating a new pull request.

Issue 4: “Runbot build hanging (no progress for hours)”

What it means: The build is stuck, possibly due to an infinite loop or deadlock.

How to fix: Check your test code for infinite loops. Look for tests that wait indefinitely for a condition. Cancel the build and fix the test code.

Issue 5: “Code coverage suddenly dropped from 85% to 45%”

What it means: You added new code that isn’t tested.

How to fix: Write tests for your new code. In tests/ directory, add test functions that exercise the new functionality.

Frequently Asked Questions About Odoo Runbot

Odoo Runbot Best Practices for Developers

1. Write Tests from Day One

Don’t write tests after development is complete. Write tests as you develop. Tests help you think through edge cases and requirements. When Runbot runs these tests, you’ll catch issues early.

2. Test Critical Paths

Focus tests on critical functionality: creating records, validating data, processing workflows. You don’t need 100% code coverage; aim for 70-80% covering the most important features.

3. Use Descriptive Test Names

Name tests to clearly describe what they test: test_create_invoice_with_negative_amount is better than test_invoice. When tests fail, descriptive names help you quickly understand what broke.

4. Test Multiple Odoo Versions

If your module supports multiple Odoo versions (e.g., 16.0, 17.0, 18.0), configure Runbot to test all versions. This prevents compatibility issues from reaching production.

5. Keep Dependencies Minimal

Avoid unnecessary dependencies. Each dependency adds complexity, increases build time, and can cause compatibility issues. Only include dependencies you actually use.

6. Document Your Test Setup

In your README.md, explain how tests work and what they validate. This helps other developers understand your testing approach and contribute effectively.

Odoo Runbot for UAE Implementation Partners & Development Teams

If you’re an Odoo implementation partner or development team in UAE, Saudi Arabia, or the Middle East, Runbot is essential for managing custom Odoo development at scale.

Why Runbot Matters for Implementation Teams

• Multiple Projects: Managing multiple client projects requires reliable testing infrastructure. Runbot automates this for dozens of projects simultaneously.
• Team Coordination: When multiple developers work on the same client project, Runbot ensures all code changes are tested before merging.
• Quality Assurance: Runbot provides objective, automated quality checks. No more “I think this works” deployments—every change is verified.
• Client Confidence: Show clients that your custom code is tested and verified. A passing Runbot build is proof of quality.
• Production Risk Reduction: Fewer bugs reach production because Runbot catches issues before deployment.

Transines Solutions Runbot Services in UAE:

• Self-hosted Runbot setup and configuration for private client work
• Testing framework design tailored to your modules
• Test automation best practices consulting
• CI/CD workflow optimization
• Developer training on Runbot and test-driven development

Ready to Master Odoo Runbot?

Start implementing automated testing for your Odoo modules. Whether you’re a solo developer or an implementation team, Runbot improves code quality and reduces production risks.

Contact Transines Solutions:
Phone: +971 52 696 2303 | Email: odoo@transines.com
Based in Dubai, UAE | Certified Odoo Silver Partner

Internal Links for Odoo Learning:
What’s Included in Odoo ERP | Odoo Implementation Services | Odoo FAQ Complete Guide | Why Odoo Implementations Fail

About This Guide: Published July 2026 by Transines Solutions. Information reflects Odoo Runbot capabilities as of 2026. Always verify current Runbot features and requirements at Odoo Runbot GitHub for latest updates.

© 2026 Transines Solutions. Certified Odoo Silver Partner | Dubai, UAE | transines.com