Odoo Automation Rules: Triggers, Actions, Approvals, and Scheduled Jobs

What automation in Odoo can do

Odoo's automation system has four building blocks:

• Automation Rules — event-triggered (record created, updated, deleted, or value changed). Configured at Settings ‣ Technical ‣ Automation Rules.
• Server Actions — the work that happens when triggered. Send email, create record, update fields, run Python code, or chain multiple actions.
• Scheduled Actions — cron jobs that run on a schedule. Used for periodic checks: "every morning, find overdue invoices."
• Approvals — multi-step approval workflows for documents (purchase orders, expense claims, time off, etc.).

Together, these cover most operational automation needs without custom code. For complex multi-step processes with branching logic, Studio's approval framework adds visual workflow design.

Anatomy of an automation rule

Every automation rule has four parts:

1. Trigger

What event activates the rule. Common triggers:

• On Creation — record was created.
• On Update — record's fields changed.
• On Creation & Update — both.
• Based on Form Modification — user has the form open and changes a value (real-time UI response).
• Based on Timed Condition — time-based, e.g., "7 days after order confirmed."
• On Deletion — record being deleted.

2. Model

Which Odoo model the rule applies to (sale.order, res.partner, account.move, etc.).

3. Conditions

Domain filter that narrows when the rule fires. Example: a rule on sale.order with the condition amount_total > 10000 AND state == sale fires only on confirmed orders over €10,000.

4. Actions

What happens when triggered. One or many actions in sequence.

Common automation pattern 1: Approval routing

Route high-value sale orders to a senior salesperson for review before confirmation.

Setup

1. Create an automation rule on sale.order with trigger On Update.
2. Set Trigger Field to State. Set the condition to fire when state changes from draft to sent (quotation sent to customer).
3. Add a domain filter: amount_total > 10000.
4. Add a Send Email action: notify the senior salesperson with the order details and a link to review.
5. Optionally, add a Update Record action: set user_id to the senior salesperson, ensuring the order is assigned to them for follow-up.

What happens in operation

A junior sales rep creates a €15,000 quotation and sends it. The state transitions from draft to sent. The rule fires. The senior salesperson gets an email with the order summary and a one-click link to review. They can adjust pricing, escalate, or approve before the customer signs.

The mechanism is configurable in minutes; the same outcome via email or chat takes weeks of training and is enforced inconsistently.

Common automation pattern 2: Recurring reminders

Send reminders for invoices that are 7, 14, and 30 days overdue.

Setup

1. Create three automation rules on account.move (the invoice model), each with trigger Based on Timed Condition.
2. Set the Trigger Date field to invoice_date_due and Delay to 7 days, 14 days, and 30 days respectively.
3. Add the condition state == 'posted' AND payment_state in ('not_paid', 'partial') — only post-due, unpaid invoices.
4. Add a Send Email action with a reminder template per stage. The 7-day reminder is friendly; the 14-day is firm; the 30-day mentions collections.
5. Optionally add an Update Record action on the 30-day rule to flag the customer for credit hold.

The scheduling detail that matters

Timed-condition rules run via Odoo's scheduler, typically every 4 hours. The reminder fires within the next scheduler run after the threshold is crossed — not exactly at the moment. This is fine for collections; not appropriate for time-critical workflows where instant response matters.

Common automation pattern 3: Inventory reordering

The standard reordering rule (covered in Warehouse Management) handles min/max thresholds. Automation rules add custom logic: "if a high-velocity SKU drops below safety stock, create a same-day purchase order; otherwise wait for the daily replenishment run."

Setup

1. Create an automation rule on stock.quant with trigger On Update, watching the quantity field.
2. Add a condition: product_id.x_velocity_class == 'A' AND quantity < product_id.x_safety_stock (assuming you've added custom fields for velocity class and safety stock).
3. Add a Run Python Code action that creates an emergency purchase order, sends an email to the buyer, and posts to the operations Slack channel.

Why this pattern works

Standard reordering rules run on schedule. For high-velocity SKUs where stockout cost is high, scheduled runs may be too slow. Event-driven automation responds in seconds.

Common automation pattern 4: Notification chains

Notify the right people at the right stage of a multi-step process. Example: customer onboarding for a B2B account.

The flow

1. Sales rep creates a new B2B partner with customer_rank > 0 and a custom flag x_b2b_onboarding = True.
2. Automation fires on partner creation. Sends email to credit team for credit limit review.
3. Credit team sets x_credit_approved = True. Automation fires on update. Sends email to operations team to set up account portal access.
4. Operations team sets x_portal_active = True. Automation fires on update. Sends welcome email to the customer with portal credentials.

Each step is a separate automation rule. The chain is implicit through the field updates, not encoded as a workflow diagram.

When to use Odoo Studio's approval framework instead

For multi-step workflows with explicit states ("awaiting credit review," "awaiting operations setup," "active"), Odoo Studio's approval framework provides a visual workflow with a clear status field. It's overkill for 2-step approvals; well-suited for 4+ step workflows or workflows with branching logic.

Server actions: the action layer

Automation rules and scheduled actions trigger server actions. Server actions can be:

• Update Record — set fields on the triggering record (or related records).
• Create Record — create a new record (e.g., a follow-up activity, a related document).
• Send Email — using a configured template.
• Send SMS — using Odoo SMS module.
• Schedule Activity — create a to-do for a user (appears in their inbox).
• Run Python Code — for logic not covered by other action types.
• Execute Several Actions — chain multiple actions in sequence.

The Run Python Code action

For anything not handled by the structured actions, Python code gives full access to the Odoo ORM. The code runs with the rule's user privileges. Use sparingly — code in automation rules is harder to maintain than code in modules.

# Example: send Slack notification on high-value order
import requests
record.ensure_one()
if record.amount_total > 50000:
    requests.post(
        'https://hooks.slack.com/services/...',
        json={
            'text': f'High-value order {record.name}: €{record.amount_total:,.0f} from {record.partner_id.name}'
        }
    )

Scheduled actions: the time layer

Scheduled actions are cron jobs. Configure at Settings ‣ Technical ‣ Scheduled Actions.

Common uses

• Nightly reconciliation jobs — verify that storefront inventory matches Odoo inventory.
• Periodic reports — generate weekly KPI summaries and email them.
• Cleanup tasks — archive old records, expire outdated promotions, close stale opportunities.
• Integration polling — pull data from external systems on a schedule.

Configuration

Each scheduled action has: model, code (Python), interval (minutes/hours/days/weeks), and active flag. Odoo's scheduler runs scheduled actions at their intervals, queued by the system cron worker.

Discipline that makes automation sustainable

1. Document every rule

Six months from now, when the rule fires unexpectedly, the next person needs to understand why. Use the rule's description field to explain: what business need it meets, what conditions trigger it, who owns it.

2. Test before activating

Every rule has an Active toggle. Configure with active off; create test records that should trigger; verify the rule fires correctly; activate.

3. Monitor for runaway rules

A rule that updates the record it watches can fire repeatedly (it triggers itself). Add idempotency checks ("don't act if already acted within X minutes") and monitor execution counts.

4. Avoid clever conditions in Python actions

If you need complex logic, put it in a custom module rather than in a Python action. Modules are version-controlled; Python actions buried in automation rules are not.

5. Don't automate broken processes

If the manual workflow has issues — wrong people doing wrong things at wrong times — automation amplifies the problems. Fix the process first; automate it second.

Common pitfalls

1. Rules firing on the wrong trigger

The rule was meant to fire when an order is confirmed, but the trigger is set to On Creation — so it fires on quotation creation, before confirmation. Test the trigger: does it fire at the moment you expect? Use field-change triggers ("when state changes to sale") rather than generic update triggers when a specific transition matters.

2. Conditions that don't match the data shape

The condition amount_total > 10000 works on the Odoo desktop UI but fails when checking on a draft sale order where amount isn't computed yet. Verify conditions evaluate as expected at the trigger moment.

3. Email actions sending too many emails

An update rule fires on every save, sending an email each time. Users click Save twice; the customer gets two emails. Use field-change triggers, or add throttling logic in Python actions.

4. Recursion through field updates

Rule fires on update, action updates a field, that update fires another rule, and so on. Test for recursion. Add explicit guards in Python actions.

5. No audit trail

An automation rule fired six months ago and changed something; no one remembers; the rule's behavior is now considered "the way the system works." Log significant rule executions to the chatter (mail.message) or to a dedicated audit log so the change history is queryable.