A build-to-order Odoo module that models true project hierarchies — parent projects with nested subprojects — and rolls timesheet effort, budget, and progress up the tree into one analytical reporting view. ECOSIRE scopes, builds, installs, and supports it for you. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $299.00 USD; request a quote for a scoped proposal.

A build-to-order Odoo module that models true project hierarchies — parent projects with nested subprojects — and rolls timesheet effort, budget, and progress up the tree into one analytical reporting view. ECOSIRE scopes, builds, installs, and supports it for you.
ابھی کوئی ادائیگی نہیں۔ یہ ہماری ٹیم کو قیمت کی درخواست بھیجتا ہے — ہم قیمت اور اگلے اقدامات کے ساتھ ای میل کے ذریعے رابطہ کریں گے۔
Odoo's project.project and project.task models handle a single project well, but multi-tier delivery breaks the native reporting story. Once a program is split into a parent engagement with several subprojects — each carrying its own tasks, timesheets, and deadlines — there is no core object that represents "this project and everything beneath it." Managers end up exporting timesheet lines to a spreadsheet to answer basic questions: how many hours has the whole program consumed, how does logged effort compare across sibling subprojects, and which branch of the tree is drifting past its planned hours. The native Project analysis views and the timesheet grid stop at a flat, per-project grouping; they do not aggregate recursively across a hierarchy.
Adds a `parent_id` self-reference to `project.project` with a stored `complete_name` and `parent_path` hierarchy field for unlimited nesting depth
Recursive stored computes (`@api.depends`) that aggregate logged hours across a project and all descendant subprojects
Roll-up of `account.analytic.line` timesheet records so effort sums up the tree, not just per flat project
Planned-vs-actual hours variance computed per node and per subtree, surfaced as stored, indexed fields
Dedicated analysis model (or SQL-backed report view) that flattens the hierarchy into one dataset for pivot and graph views
Pivot, graph, and list reporting views grouped by parent project, subproject, employee, or task stage
Project Analysis is a made-to-order Odoo module that ECOSIRE designs and builds around your project structure. We add an explicit parent/child relationship to project.project (a parent_id self-reference plus a stored complete_name and a parent_path hierarchy field) so a project can own subprojects to any depth. On top of that we build computed roll-up fields — total logged hours, effort by subproject, planned-vs-actual variance, and progress — as stored @api.depends computes that recurse over the child set and sum the related account.analytic.line timesheet records. Because the aggregates are stored and indexed, they drive fast pivot, graph, and list reporting views, and they respect the same access rules your users already have.
Technically, the build is a clean custom addon with its own __manifest__.py (depending on project and hr_timesheet, and optionally sale_timesheet if you bill from these hours). We ship the hierarchy fields and recursive computes in models/, a dedicated analysis model (a models.Model or a SQL-backed report view) that flattens the tree into one queryable dataset for the pivot/graph, QWeb PDF summaries per parent project, and — where useful — an automated action that flags a subproject when its actual hours cross a configured percentage of plan. Security is handled properly with ir.model.access.csv entries and record rules so a project manager only sees their own hierarchy, and every new field is exposed through XML/OWL view extensions rather than overriding core views destructively. Everything is compatible with Odoo 17.0, 18.0, and 19.0, and works on both Community and Enterprise (with the richer analytic/billing tie-ins lighting up on Enterprise where sale_timesheet and advanced accounting are present). The same roll-up data is reachable over the XML-RPC/JSON-RPC API for external dashboards.
Because this is build-to-order, nothing ships until we agree on scope. We start with a short scoping call, map your real project hierarchy and timesheet practice, then build, test on a staging database with your data, and run UAT before touching production. Typical delivery is 2–4 weeks from confirmed scope. Pricing starts from $299 (indicative, single-company base scope); multi-company consolidation, deep analytic-account and billing integration, additional custom KPIs, and heavy historical-data migration each increase the quoted scope. You receive a fixed quote after the scoping call — never a surprise invoice.
Runs multi-tier programs where one parent engagement spans several subprojects. Needs a single view of total effort, per-branch drift, and progress without exporting timesheets to a spreadsheet every week.
Delivers client work billed from timesheets across nested workstreams. Wants roll-up hours reconciled against plan and, on Enterprise, against sales orders to protect margin.
Owns budget-vs-actual across departments modelled as project hierarchies. Needs stored, auditable roll-up figures reachable over the API for downstream BI and month-end reporting.
Maintains the internal Odoo instance and wants a clean, inherited addon with proper access rules and documentation — not a fragile core-view override — that upgrades cleanly across 17/18/19.
Buy the license on ecosire.com and download the Project Analysis module ZIP from your account dashboard.
Extract the ZIP into your Odoo custom addons folder on the server (or upload via Apps > Install from file on Odoo.sh / runbot).
Activate Developer Mode, open Apps, click Update Apps List, search for Project Analysis, and press Install.
Open the new menu, paste your ECOSIRE license key, connect any external credentials (Shopify, Amazon, Stripe, etc.), and save.
Run the built-in connection test, sync your first 10 records, and schedule the recurring cron. Contact support if anything fails.
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Subproject hierarchy roll-up | Recursive stored computes sum effort across the whole tree | Possible but you design and maintain the recursion yourself | Often flat or single-level parent links only | |
| Timesheet aggregation | Sums `account.analytic.line` up the subtree, stored and indexed | Depends on your developer's approach and performance care | Varies; frequently unstored, so pivots are slow | |
| Fit to your structure | Built to your real hierarchy and KPIs after a scoping call | Fully bespoke but you own the spec and the risk | Generic — you adapt your process to the module | |
| Reporting views | Pivot, graph, list, plus QWeb PDF roll-up per parent | Whatever you commission and build | Usually a fixed set you cannot easily extend | |
| Security & access | Record rules + `ir.model.access.csv` scoped to each manager | Must be designed and reviewed in-house | Baseline access, rarely hierarchy-aware | |
| Version support | Delivered for 17.0/18.0/19.0, Community or Enterprise | You maintain compatibility each upgrade | Tied to the vendor's supported versions | |
| Delivery model | Scoped, built, UAT on staging, installed, supported | In-house or contractor time you manage | Self-install, self-support after purchase | |
| Ongoing support | Post-go-live window + optional upgrade retainer | Your team carries it | Vendor tickets, variable SLA |
No. Project Analysis is build-to-order. ECOSIRE builds it around your actual project hierarchy and timesheet practice, then installs and supports it. There is no instant download — the value is a module fitted to how your teams actually structure work.
Typical delivery is 2–4 weeks from confirmed scope. The timeline starts once we've agreed the data model, roll-up KPIs, and reporting views on the scoping call and you've signed off the fixed quote. Larger multi-company or migration-heavy builds sit at the upper end of that range.
Pricing starts from $299 (indicative, single-company base scope). After a short scoping call we send a fixed quote — no surprise invoicing. Multi-company consolidation, deep analytic/billing integration, extra custom KPIs, and heavy historical-data migration increase the quoted scope.
Every build includes a post-go-live support window for defect fixes and questions. Beyond that we offer ongoing support and version-upgrade retainers — for example when you move from Odoo 17 to 18 or 19 — so the roll-up fields and reports stay compatible as core evolves.
It runs on both. The hierarchy and timesheet roll-up work on Community with `project` and `hr_timesheet`. On Enterprise we can additionally tie into `sale_timesheet` and advanced analytic accounting so billable roll-up hours reconcile against sales orders.
No. We extend `project.project` with inherited fields and inherit core views via XML/OWL rather than replacing them, and we test everything on a staging copy of your database with a documented rollback plan before touching production.
Yes. The aggregates are stored, indexed fields and a flat analysis dataset, all reachable over the XML-RPC/JSON-RPC API. You can pull program-level effort and variance into Power BI or any external reporting layer on a schedule.
A build-to-order Odoo module that models true project hierarchies — parent projects with nested subprojects — and rolls timesheet effort, budget, and progress up the tree into one analytical reporting view. ECOSIRE scopes, builds, installs, and supports it for you.