Skip to main content
Surgery Management — A build-to-order Odoo module for surgical case scheduling, pre-op safety checklists, and surgical team a — 1/1Illustrative preview

A build-to-order Odoo module for surgical case scheduling,

pre-op safety checklists, and surgical team assignment. Requested by quotation and built, installed, and supported by ECOSIRE for Odoo 17.0/18.0/19.0.

What is Surgery Management?

A build-to-order Odoo module for surgical case scheduling, pre-op safety checklists, and surgical team assignment. Requested by quotation and built, installed, and supported by ECOSIRE for Odoo 17.0/18.0/19.0. 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

`surgery.case` model as the single record for each operation — patient (`res.partner`), procedure, primary surgeon, care team, theatre, and clinical fields (ASA grade, laterality/side, anaesthesia type, priority/emergency flag)
State machine `draft → scheduled → checklist_ready → in_progress → recovery → completed` (plus `cancelled`) with guarded transitions, so a case cannot skip its safety gate
Server-side double-booking prevention: `@api.constrains` overlap checks block the same theatre or the same surgeon being scheduled in overlapping windows
`surgery.theatre` resource model with working-hours calendar and configurable turnaround/cleaning buffer feeding computed expected-end-time via `@api.depends`
Configurable safety checklists (`surgery.checklist.template` + `surgery.checklist.line`) grouped by sign-in / time-out / sign-out phases — hospital-editable, not hard-coded
Hard checklist gate: mandatory sign-in and time-out lines must be confirmed (with confirming user + timestamp) before the case can move to `in_progress`
Surgical team assignment with per-member role, role-qualification enforcement, and availability checks against theatre schedule and `hr` time-off
Theatre-day scheduling view — Gantt drag-to-reschedule on Enterprise, equivalent OWL calendar/planning view on Community so nothing is lost
QWeb reports: printable daily operating schedule per theatre and a per-case surgical record / checklist sheet for the patient chart
Automated pre-op reminders and unconfirmed-checklist escalations via `ir.cron` / base automation, addressed to the assigned surgeon and OR coordinator
Access control via `ir.model.access.csv` plus record rules — distinct scopes for surgeons, OR coordinators, and read-only auditors, multi-company aware where required
Optional instrument/implant requirements per procedure linked to `stock` so required sets are visible on the case and shortfalls flagged before the schedule locks
Full XML-RPC / JSON-RPC API surface on all models for integration with EMR, LIS, imaging, bed-management, or billing systems
Mail/chatter and activity tracking on `surgery.case` for cancellation reasons, delays, and clinical notes with a complete audit trail
Built and tested against Odoo 17.0, 18.0, and 19.0 with a clean `__manifest__.py`, versioned dependencies, and demo/config data

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

Hospitals and surgical centers running Odoo hit a wall when the operating room becomes the coordination bottleneck. A surgical case is not a sales order or a calendar event: it needs a booked theatre and time block that cannot double-book, a named surgeon plus anaesthetist and scrub/circulating nurses whose availability and role qualification must be checked, a procedure with an expected duration, required instrument sets and implants, and a sign-off trail proving the sign-in / time-out / sign-out safety steps were actually completed before the first incision. Odoo core gives you calendar.event, hr.employee, project.task and stock — useful primitives, but none of them model theatre capacity, enforce a checklist gate, or hold the clinical fields (ASA grade, procedure side/laterality, anaesthesia type) that a real OR schedule depends on. Teams end up managing surgery in spreadsheets and whiteboards alongside Odoo, and the two never reconcile.

ECOSIRE builds a dedicated Surgery Management application for your Odoo database. At its core is a surgery.case model (models.Model) linking the patient (res.partner), the primary surgeon and full care team (hr.employee), the operating room (a surgery.theatre resource with working-hours and turnaround-time), the procedure catalogue, and a state machine (draft → scheduled → checklist_ready → in_progress → recovery → completed, with cancelled). Scheduling conflicts are prevented server-side: an overlap constraint (@api.constrains plus an SQL exclusion where appropriate) blocks two cases claiming the same theatre or the same surgeon in the same window, and @api.depends computes expected end time from procedure duration and turnaround buffer. Safety checklists are their own models — a configurable surgery.checklist.template with surgery.checklist.line items grouped by phase — and a case cannot advance to in_progress until every mandatory sign-in and time-out line is confirmed, giving you a hard, auditable gate rather than a reminder people ignore.

The team-assignment side enforces the rules that matter clinically: role-qualification checks so only staff flagged for a role can be assigned to it, availability checks against the theatre schedule and time-off, and a clean many-to-many of team members per case with their role. On top of the data model we build the operational surface: a theatre-day Gantt/calendar view (OWL-based drag-to-reschedule where your edition supports it), kanban by state, a QWeb operating-schedule report and per-case surgical record / checklist PDF for printing or the chart, and automated actions (ir.cron / base automation) for pre-op reminders and unconfirmed-checklist escalations. Access is locked down with ir.model.access.csv plus record rules so surgeons, OR coordinators, and read-only auditors each see the appropriate scope, and every schedule and integration point is reachable over Odoo's XML-RPC/JSON-RPC API for your imaging, LIS, or bed-management systems. We target Odoo 17.0, 18.0, and 19.0 and are explicit about Community vs Enterprise: the full data model, checklists, security, reports and calendar views run on Community, while the native drag-and-drop Gantt planning widget is an Enterprise convenience — on Community we deliver an equivalent calendar/OWL scheduling view so no capability is lost, only the exact widget differs.

Because this is build-to-order, nothing is downloaded and switched on instantly. After you request a quotation we run a short scoping call, confirm the exact scope in writing, then build, test on a staging copy of your database, and hand over — typical delivery is one working week from confirmed scope depending on complexity and integrations. Pricing starts from $999 (indicative, single-company base scope); multi-hospital / multi-company theatre pools, deeper localization, and integrations with external clinical systems (EMR, LIS, imaging, billing) increase the quoted scope. You receive a fixed quote after the scoping call, never a surprise bill.

What you get

  • Installable, readable source code for the Surgery Management module built for your target Odoo version (17.0 / 18.0 / 19.0)
  • Installation and configuration on your environment (or guided install), including theatre setup, checklist templates, roles, and security groups
  • Technical documentation: data model reference, security matrix, `__manifest__.py` dependencies, cron/automation catalogue, and API endpoints
  • User guide plus a live training session for OR coordinators, surgeons, and admin staff
  • Post-go-live support window for defect fixes and configuration questions on the delivered scope
  • UAT on a staging copy of your database with a documented test plan and a rollback plan before production cutover
  • Git repository handover with full commit history and tagged release for your target version
  • Configured demo/seed data (sample theatres, procedures, and checklist templates) to accelerate onboarding

Who this is for

OR Coordinator / Theatre Scheduler

Owns the daily operating schedule and lives in the theatre-day view. Needs conflict-free booking, at-a-glance team and equipment readiness, and printable schedules — without juggling a whiteboard next to Odoo.

Surgeon / Clinical Lead

Wants a reliable picture of their own list, correct laterality and procedure details, and confidence that the safety time-out was genuinely completed. Values the checklist gate and the per-case surgical record PDF.

Hospital IT / Odoo Administrator

Runs the Odoo instance and needs clean, maintainable source with proper `ir.model.access.csv`, record rules, and an XML-RPC/JSON-RPC surface to integrate with the EMR/LIS — plus a git handover they can maintain.

Quality & Compliance Officer

Requires an auditable trail that safety checklists were completed before incision, with confirming user and timestamp, and read-only access to schedules and case history for reviews and accreditation.

How Surgery Management Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Fit to your OR workflowBuilt to your theatres, roles, and checklist rules after scopingFully bespoke but you specify and manage everythingFixed feature set; you adapt your process to itNo surgery model at all — generic calendar and tasks only
Double-booking preventionServer-side overlap constraints on theatre and surgeonPossible, but you design and test the constraint logicVaries; often calendar-level only, not enforced clinicallyNone — nothing stops overlapping bookings
Safety checklist enforcementHard state-machine gate with confirming user and timestampAchievable if you build and validate the gate yourselfMay include a checklist, rarely a blocking gateNot available
Odoo version supportBuilt and tested for 17.0, 18.0, or 19.0 as neededWhatever your team targets and maintainsDepends on vendor's release cadenceShips with your Odoo version but without surgery features
Source code and ownershipFull readable source plus git repo handoverYou own it, but you also carry all the build costOften obfuscated or licence-restrictedCore Odoo source; no surgery module to own
Delivery timeTypically one working week from confirmed scopeLonger — full discovery, build, and QA from scratchInstant install, but then heavy configuration/workaroundsImmediate, but the capability simply is not there
Support and accountabilityPost-go-live support window plus optional retainer, one vendorRests on your internal team or contractor availabilityGeneric vendor support queue, limited customization helpCommunity/your Odoo partner; no feature-specific support
Cost modelIndicative from $999; fixed quote after scopingHigh upfront developer cost and ongoing maintenanceLow licence fee plus hidden configuration/gap costNo extra cost, no functionality

Frequently Asked Questions about Surgery Management

Is this an existing app I can download and install today?

No. Surgery Management is build-to-order. ECOSIRE builds it for your specific Odoo version and requirements after you request a quotation — it is not an instant apps.odoo.com download. This lets us match your theatres, checklist rules, roles, and integrations rather than forcing your workflow into a fixed template.

How long until it is delivered?

Typical delivery is one working week from confirmed scope. The clock starts once we have completed the scoping call and agreed the scope in writing. Simpler single-hospital builds land toward the shorter end; multi-company theatre pools and external clinical-system integrations sit toward the longer end. We give you a target timeline in the fixed quote.

How does pricing and scoping work?

Pricing starts from $999 as an indicative from-price for a single-company base scope. After a short scoping call we send a fixed written quote — no surprise bills. Drivers that increase scope include multi-hospital/multi-company theatre pools, deeper localization, data migration volume, and integrations with EMR, LIS, imaging, or billing systems.

What about support and updates after go-live?

Every build includes a post-go-live support window for defect fixes and configuration questions on the delivered scope. Beyond that we offer ongoing support and enhancement retainers. Because you receive the full source and a git repository, you are never locked in — your own team can also maintain it. Version upgrades (e.g. 18.0 to 19.0) are quoted as a separate scoped task.

Does it run on Odoo Community or only Enterprise?

The full data model, safety checklists, team assignment, security, QWeb reports, and calendar scheduling run on Odoo Community. The native drag-and-drop Gantt planning widget is an Enterprise convenience; on Community we deliver an equivalent OWL calendar/planning view so you keep the scheduling capability. We confirm your edition during scoping and build accordingly for 17.0, 18.0, or 19.0.

Can it integrate with our EMR, LIS, or imaging systems?

Yes. All models expose Odoo's standard XML-RPC/JSON-RPC API, so external clinical systems can read and write cases, schedules, and checklist status. We scope the specific integrations you need — patient sync, results, billing handoff — as part of the quote, since each external system adds to the delivered scope.

Is the safety checklist actually enforced, or just a reminder?

It is enforced server-side. A case cannot transition to in-progress until every mandatory sign-in and time-out checklist line is confirmed, and each confirmation records the user and timestamp. This is a hard gate in the state machine backed by an audit trail — not a soft reminder that staff can dismiss.

Request a quote

Surgery Management

A build-to-order Odoo module for surgical case scheduling, pre-op safety checklists, and surgical team assignment. Requested by quotation and built, installed, and supported by ECOSIRE for Odoo 17.0/18.0/19.0.

  • `surgery.case` model as the single record for each operation — patient (`res.partner`), procedure, primary surgeon, care team, theatre, and clinical fields (ASA grade, laterality/side, anaesthesia type, priority/emergency flag)
  • State machine `draft → scheduled → checklist_ready → in_progress → recovery → completed` (plus `cancelled`) with guarded transitions, so a case cannot skip its safety gate
  • Server-side double-booking prevention: `@api.constrains` overlap checks block the same theatre or the same surgeon being scheduled in overlapping windows
  • `surgery.theatre` resource model with working-hours calendar and configurable turnaround/cleaning buffer feeding computed expected-end-time via `@api.depends`

Request a Quotation

Tell us about your Surgery Management 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.