Boost ERP Performance

Odoo load testing remains a critical step for any company that scales its operations. Accordingly, this tutorial explains every concept and step clearly. First, we define “Odoo load testing” and then we guide you through setting up Locust, writing scripts, running tests, and analyzing results. Next, we share best practices for realistic user scenarios, database logging, and performance tuning. As a result, you will master how to stress‑test your Odoo instance, ensuring stable ERP performance under heavy load.

Why Odoo Load Testing Matters

Odoo load testing evaluates how your ERP handles many simultaneous users. Therefore, you can spot bottlenecks early and prevent slowdowns in production. Moreover, load testing Odoo helps you validate hardware capacity, database settings, and custom code. In addition, this process provides insights into response times, throughput, and error rates. Consequently, your team gains confidence that Odoo will perform under real‑world pressure.

First, you simulate typical user workflows such as logging in, creating invoices, or validating sales orders. Then, you measure how long each action takes as you ramp up concurrent users. Therefore, load testing Odoo answers important questions: How many users can the server support? Which modules need optimization? Finally, you refine your infrastructure or code to meet service‑level objectives.

Setting Up Your Load Testing Environment

Before writing any script, prepare your environment step by step. First, install Python 3.8 or later on a separate machine or container. Next, create a new virtual environment and activate it. Then, install Locust, the open‑source load testing tool, by running pip install locust. Locust provides a flexible API for simulating user behavior, making it ideal for Odoo load testing.

Prerequisites and Tools

You need Python, pip, and git. Additionally, ensure you have network access to your Odoo instance. If Odoo runs behind a firewall, whitelist your test machine’s IP. In addition, you require an admin user on Odoo to generate API keys or session cookies for authentication.

Installing Locust

First, open a terminal. Then, type:

python3 -m venv odoo_load_env
source odoo_load_env/bin/activate
pip install locust

After installation, verify Locust works by typing locust --help. You will see usage instructions and options.

Configuring Odoo for Performance Logging

Next, configure your PostgreSQL database to log every query. In your postgresql.conf, set:

log_min_duration_statement = 0
log_statement = 'all'

Then, restart PostgreSQL. As a result, you capture all SQL queries in Odoo logs. Later, you analyze slow queries to fine‑tune indexes or ORM code.

Building Odoo Load Testing Scripts with Locust

In this section, you create a Python script that defines user behavior. First, you extend Locust’s HttpUser class to simulate an Odoo user. Next, you group common actions into tasks. Then, you set up realistic wait times to mimic human interaction.

Defining the OdooUser Class

First, create a file named locustfile.py. Next, import necessary modules and define your user class:

from locust import HttpUser, task, between

class OdooUser(HttpUser):
    wait_time = between(1, 5)  # Users wait between 1 and 5 seconds

    def on_start(self):
        """Authenticate once per simulated user session."""
        response = self.client.post(
            "/web/session/authenticate",
            json={
                "jsonrpc": "2.0",
                "params": {
                    "db": "my_odoo_db",
                    "login": "user@example.com",
                    "password": "securepass"
                }
            }
        )
        assert response.status_code == 200
        self.session_id = response.json()["result"]["session_id"]

First, you set a realistic wait time. Then, in on_start, you authenticate against Odoo’s JSON‑RPC endpoint. As a result, every task runs under a valid session.

Creating Task Sets

Next, define tasks that represent common operations. For example, invoice creation and validation:

    @task(3)
    def create_invoice(self):
        """Simulate creating and validating an invoice."""
        # Step 1: Create draft invoice
        create_resp = self.client.post(
            "/web/dataset/call_kw/account.move/create",
            json={
                "jsonrpc": "2.0",
                "method": "call",
                "params": {
                    "model": "account.move",
                    "method": "create",
                    "args": [{
                        "move_type": "out_invoice",
                        "partner_id": 1
                    }]
                }
            }
        )
        invoice_id = create_resp.json()["result"]

        # Step 2: Validate the invoice
        self.client.post(
            "/web/dataset/call_kw/account.move/action_post",
            json={
                "jsonrpc": "2.0",
                "method": "call",
                "params": {
                    "model": "account.move",
                    "method": "action_post",
                    "args": [[invoice_id]]
                }
            }
        )

First, you use the RPC endpoint to create a new invoice. Next, you call action_post to validate it. As a result, you replicate a real‑world user workflow.

Simulating Front‑End Interactions

In addition to RPC calls, you may need to simulate HTTP requests to Odoo’s web client. For example, loading a dashboard:

    @task(1)
    def load_dashboard(self):
        """Fetch the Odoo dashboard page."""
        self.client.get("/web#action=board057")  # Example dashboard ID

Then, ensure you include a referer header or session cookie if necessary.

Setting Realistic Data and Weights

First, assign weights to tasks based on frequency: invoice creation may occur more often than dashboard views. Next, populate your database with at least 1000 partners, 5000 products, and 10000 invoices to avoid caching effects. As a result, every test run exercises a realistic dataset.

Running Your Odoo Load Test and Analyzing Results

After scripting, you execute the test and interpret performance metrics. First, start Locust in web mode by running:

locust -f locustfile.py --host http://odoo.mycompany.com

Next, open your browser at http://localhost:8089. Then, set the number of users and spawn rate. As a result, Locust will generate concurrent sessions that follow your script.

Viewing Live Metrics

First, the Locust UI displays charts for requests per second, failure rate, and response times. Next, you monitor the console logs for warnings or errors. In addition, you open Odoo server logs to track SQL queries. As a result, you gain a comprehensive view of both front‑end and back‑end performance.

Analyzing Database Queries

After the test, review PostgreSQL logs. Because you set log_min_duration_statement = 0, you see every query. Then, use tools like pgBadger to generate HTML reports. As a result, you pinpoint slow queries and missing indexes.

Exporting and Sharing Results

Next, you can export test results to CSV via the Locust UI. Then, share the report with your development team. Consequently, they can optimize modules or adjust server configuration.

Optimizing Odoo Load Testing for Realistic Scenarios

To make your Odoo load testing more effective, follow these guidelines. First, always use production‑like data. Next, avoid vendor‑provided dummy data only; instead, mirror your own customer records. Furthermore, simulate business hours by varying user arrival patterns. Therefore, you mimic morning peaks and midday lulls.

Using Realistic Wait Times

First, set between(1, 5) for light tasks. Then, use between(5, 15) for complex workflows like report generation. As a result, you prevent artificial spikes that do not reflect real usage.

Setting Realistic Expectations

Next, define service‑level targets: for example, 95% of operations must complete under 500 ms. Then, compare test results against these targets. Therefore, you align your load test with business requirements.

Monitoring System Resources

In addition to Locust metrics, use tools like htop, iostat, and vmstat on your Odoo server. Furthermore, install Netdata for real‑time visualization. As a result, you correlate CPU, memory, and disk usage with load patterns.

Case Study: 10,000 Users on Odoo Instance

In a keynote demonstration, we tested a 10,000‑user scenario on a single Odoo instance. First, we ramped up to 5,000 users over 10 minutes. Next, we maintained the load for 30 minutes. Finally, we increased to 10,000 users and observed the system behavior.

Observations and Bottlenecks

At 5,000 users, the front‑end response time stayed under 200 ms. However, at 8,000 users, database CPU soared above 80%. Consequently, transaction throughput dropped by 25%. Therefore, we identified that our PostgreSQL settings needed tuning:

• We increased max_connections to 1000.
• We raised shared_buffers from 2 GB to 4 GB.
• We enabled work_mem of 50 MB.

As a result, the system handled 10,000 users with a peak average response time of 450 ms.

Lessons Learned

First, you must test with realistic data sizes. Then, ensure your database tuning matches your hardware. Next, use connection pooling via PgBouncer to reduce connection overhead. Finally, consider horizontal scaling with Odoo workers or multiple application servers.

Conclusion

Odoo load testing empowers you to validate ERP performance before going live. First, you script real‑world workflows with Locust. Next, you run tests, monitor metrics, and analyze database logs. Then, you optimize configurations and re‑test. Therefore, you build confidence that your Odoo instance will handle peak loads smoothly.