Skip to main content
Manufacturing Gantt Native Web View — A build-to-order interactive Gantt timeline that plots your manufacturing work orders a — 1/1Illustrative preview

A build-to-order interactive Gantt timeline that plots your manufacturing work orders across work centers so

planners can drag, drop, and reschedule production visually.

ECOSIRE builds, installs, and supports it on your Odoo 17/18/19 instance after a scoping call.

What is Manufacturing Gantt Native Web View?

A build-to-order interactive Gantt timeline that plots your manufacturing work orders across work centers so planners can drag, drop, and reschedule production visually. ECOSIRE builds, installs, and supports it on your Odoo 17/18/19 instance after a scoping call. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Interactive OWL Gantt web view rendering `mrp.workorder` / `mrp.production` records on a horizontal timeline, registered as a dedicated action or view type
Drag-to-reschedule and edge-resize that write `date_planned_start` / `date_planned_finished` back through standard ORM `write()`, keeping all `@api.depends` computes consistent
Configurable grouping (`group_by` work center, manufacturing order, responsible user, or a custom field) chosen during scoping
Per-work-center swimlanes so planners see capacity conflicts and over-booking at a glance
`@api.constrains` guards that reject moves violating dependency order or exceeding a work center's capacity window
Dependency links between operations so a predecessor's slip visually propagates to successors on the timeline
Zoom controls for hour / day / week / month scales driven by the OWL component state
Color-coding by work-order state (ready, in progress, blocked, done) or by a custom status field
Row and date-range filtering plus a today-marker and non-working-time shading pulled from `resource.calendar`
Compute fields (`@api.depends`) for rolled-up durations, lateness, and slack surfaced directly on the bars
Record-rule and `ir.model.access.csv`-scoped visibility so planners only see the work centers or operations their groups allow
Optional automated / server actions triggered on reschedule (notify team, re-run planning, log to chatter)
Full XML-RPC / JSON-RPC read-write parity so external MES, APS, or forecasting tools drive the same schedule
Built and asset-bundled per target series via `__manifest__.py` for Odoo 17.0, 18.0, and 19.0, with Community and Enterprise editions handled explicitly

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your Odoo.

  3. 3

    Go live + support

    You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.

Technical Specifications

Odoo Compatibility
Odoo 17, Odoo 18, Odoo 19
Editions
Enterprise & Community
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
PostgreSQL 12+

About this Product

Production planners running Odoo Community — and even many Enterprise teams — hit the same wall when they try to schedule the shop floor from the standard mrp.production and mrp.workorder list and calendar views. You can see that work orders exist, but you cannot see how they collide: which work center is over-booked on Tuesday, which order slips because its predecessor ran long, or where a two-hour gap could absorb a rush job. Odoo Community ships no drag-and-drop Gantt for manufacturing at all (the Gantt widget is an Enterprise component), and even where a timeline exists, it rarely reflects real work-center capacity, dependency chains, or your own scheduling rules. Planners end up rebuilding the picture in a spreadsheet every morning, which is exactly the manual, error-prone process Odoo was meant to replace.

This is a build-to-order module that ECOSIRE designs, builds, installs, and supports for your specific Odoo instance — it is not an existing apps.odoo.com download you install yourself. We deliver an interactive Gantt web view, rendered as an OWL component, that reads directly from your mrp.workorder and mrp.production records and lays them out on a horizontal timeline grouped by work center (or by manufacturing order, resource, or a custom group_by you choose during scoping). Each bar is driven by the order's date_planned_start / date_planned_finished (or date_start / date_finished) fields; dragging or resizing a bar writes the new schedule back through the standard ORM write() so every downstream compute — @api.depends duration rollups, state transitions, and capacity checks — stays consistent. We add compute fields and, where you need them, @api.constrains guards so the view refuses moves that break dependency order or exceed a work center's capacity.

Technically, the module is a clean, self-contained addon: a proper __manifest__.py declaring dependencies on mrp (and web), models extending mrp.workorder/mrp.production with any scheduling fields your rules require, an OWL client component plus its XML template registered as a new view type or a dedicated action, and QWeb assets bundled through the manifest's assets section. Access is governed by ir.model.access.csv and record rules so a planner sees only the work centers or manufacturing operations their groups permit — the Gantt never becomes a data-leak surface. Optional automated actions (server actions / base automation) can fire on reschedule to notify a team or re-run planning, and everything the view does is also reachable over the XML-RPC / JSON-RPC API, so external MES or forecasting tools can read and write the same schedule. We build and test against your target series — Odoo 17.0, 18.0, or 19.0 — and account for the Community-vs-Enterprise differences up front (on Enterprise we can integrate with the native Gantt renderer; on Community we ship a self-contained OWL timeline so you are not forced to upgrade edition).

Delivery is build-to-order and starts with a scoping call to confirm your Odoo version, edition, which models and date fields drive the bars, your grouping and capacity rules, and any dependency or constraint logic. We then build on a staging copy of your database, run UAT with your planners, and go live with a rollback plan and a post-go-live support window; typical delivery is one working week from confirmed scope. Pricing starts from $999 (indicative, single-company base scope); multi-company setups, deeper capacity/finite-scheduling logic, extra integrations (MES, APS, custom forecasting), and larger data-migration or reconfiguration volume increase the quoted scope. You receive a fixed quote after the scoping call — never a surprise invoice.

What you get

  • Installable, self-contained addon source code for your confirmed Odoo version and edition (`__manifest__.py`, models, OWL component + QWeb templates, security files)
  • Installation and configuration on your instance, including asset registration and access-rights setup
  • Technical documentation: model extensions, compute/constraint logic, view configuration, and upgrade notes
  • End-user guide plus a live training session for your planning team
  • UAT on a staging copy of your database with sign-off before go-live, and a documented rollback plan
  • Post-go-live support window for defect fixes and configuration questions
  • Git repository handover with full commit history so your team owns and can extend the code
  • Security review of `ir.model.access.csv` and record rules to confirm scoped, leak-free visibility

Who this is for

Production Planner / Scheduler

Runs the daily and weekly manufacturing schedule and needs to drag work orders across work centers, spot capacity clashes, and absorb rush jobs without rebuilding a spreadsheet every morning.

Manufacturing / Operations Manager

Owns on-time delivery and work-center utilization. Wants a single visual timeline that reflects real capacity and dependency rules so bottlenecks and slippage are obvious before they hurt shipments.

Odoo Community shop running MRP

Uses Odoo Community for manufacturing and has no native drag-and-drop Gantt. Needs a self-contained timeline scheduler without being forced onto the Enterprise edition.

Odoo functional consultant / integration partner

Implements Odoo for a manufacturing client and needs a supported, source-delivered Gantt scheduler that respects the standard ORM, security model, and the JSON-RPC API for downstream MES/APS integration.

How Manufacturing Gantt Native Web View Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Manufacturing Gantt on Odoo CommunitySelf-contained OWL timeline delivered for Community — no edition upgrade neededPossible but you build the whole renderer from scratchOften Enterprise-only or a generic Gantt not tuned for MRPNo drag-and-drop manufacturing Gantt in Community at all
Fit to your models and rulesBuilt around your fields, grouping, capacity and dependency logic from the scoping callFully bespoke but depends on your in-house Odoo depthFixed feature set; you adapt your process to itGeneric scheduling; no shop-specific capacity or dependency logic
Data consistency on rescheduleWrites via ORM `write()` with `@api.constrains` guards, keeping computes validDepends entirely on how carefully it is codedVaries; may bypass constraints or ignore dependenciesStandard write path but no manufacturing timeline to drive it
Security scoping`ir.model.access.csv` + record rules reviewed so planners see only permitted work centersYour responsibility to design and testUsually broad access; rarely scoped per work centerStandard MRP access rights, no Gantt-specific scoping
External integrationFull XML-RPC / JSON-RPC parity for MES/APS/forecastingAchievable, adds to build cost and timeSometimes closed; integration hooks varyAPI exists but no unified manufacturing timeline to sync
Support and ownershipPost-go-live support window plus full source and git handoverYou own it and maintain it entirely yourselfVendor-controlled roadmap; source often obfuscatedCovered by your Odoo support contract, no custom scheduler
Cost modelIndicative from $999, fixed quote after scoping — no surprise invoiceOpen-ended developer time and riskLow sticker price but limited fit and lock-inIncluded in Odoo licensing but missing the capability
Version coverageBuilt and tested for your target Odoo 17.0 / 18.0 / 19.0Whatever you build, maintained by you across upgradesDepends on vendor keeping the listing currentShips with the edition; capability simply absent on Community

Frequently Asked Questions about Manufacturing Gantt Native Web View

Is this a module I can download and install right now?

No. It is build-to-order. ECOSIRE designs, builds, installs, and supports it for your specific Odoo instance after a scoping call — there is no instant download. You receive installable source code and a git repository as part of delivery, so your team fully owns the result.

How long does delivery take?

Typical delivery is one working week from confirmed scope. The clock starts once the scoping call has fixed your Odoo version and edition, the models and date fields driving the bars, your grouping and capacity rules, and any dependency logic. Larger scope (multi-company, finite scheduling, integrations) can extend the timeline, which we state in the quote.

How does pricing and scoping work?

Pricing starts from $999 (indicative, single-company base scope). It is not a firm fixed price until we have run the scoping call. Drivers such as multi-company setups, deeper capacity/finite-scheduling logic, extra MES/APS integrations, and data-migration volume increase the quoted scope. After the call you get a single fixed quote — no surprise invoicing.

Which Odoo versions and editions do you support?

We build and test against Odoo 17.0, 18.0, or 19.0, on either Community or Enterprise. On Community we ship a self-contained OWL timeline (Community has no native manufacturing Gantt), and on Enterprise we can integrate with the native Gantt renderer instead. We confirm your exact target during scoping.

What about support and future Odoo updates?

Every build includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full source and git history, your team can maintain it directly, and we can quote a separate engagement to migrate the module to a future Odoo major version when you upgrade.

Will rescheduling from the Gantt keep the rest of Odoo consistent?

Yes. Drag and resize actions write back through the standard ORM `write()`, so `@api.depends` computes, state transitions, and any capacity or dependency constraints all re-evaluate. We add `@api.constrains` guards so the view rejects moves that break dependency order or exceed a work center's capacity.

Can external systems read and write the same schedule?

Yes. Everything the Gantt does runs through standard Odoo models, so the same records are fully accessible over the XML-RPC / JSON-RPC API. An external MES, APS, or forecasting tool can read and update the schedule and the changes appear on the timeline, subject to the same access rights and record rules.

Request a quote

Manufacturing Gantt Native Web View

A build-to-order interactive Gantt timeline that plots your manufacturing work orders across work centers so planners can drag, drop, and reschedule production visually. ECOSIRE builds, installs, and supports it on your Odoo 17/18/19 instance after a scoping call.

  • Interactive OWL Gantt web view rendering `mrp.workorder` / `mrp.production` records on a horizontal timeline, registered as a dedicated action or view type
  • Drag-to-reschedule and edge-resize that write `date_planned_start` / `date_planned_finished` back through standard ORM `write()`, keeping all `@api.depends` computes consistent
  • Configurable grouping (`group_by` work center, manufacturing order, responsible user, or a custom field) chosen during scoping
  • Per-work-center swimlanes so planners see capacity conflicts and over-booking at a glance

Request a Quotation

Tell us about your Manufacturing Gantt Native Web View requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.