Skip to main content
Website Page Restore, Revision & History — A build-to-order Odoo module that captures a full revision history for every websi — 1/1Illustrative preview

A build-to-order Odoo module that captures a full revision history for every website page,

letting your team compare versions, roll back mistakes, and restore any prior state with one click.

ECOSIRE designs, builds, installs, and supports it after a scoping call — it is not an instant download.

What is Website Page Restore, Revision & History?

A build-to-order Odoo module that captures a full revision history for every website page, letting your team compare versions, roll back mistakes, and restore any prior state with one click. ECOSIRE designs, builds, installs, and supports it after a scoping call — it is not an instant download. 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

Automatic `arch_db` snapshot of each website page on every save, stored as immutable `website.page.revision` rows keyed to the `ir.ui.view`
Content-hash de-duplication so identical or no-op saves do not generate noise revisions
Per-revision metadata: author (`create_uid`), timestamp, optional change note, and originating source (backend, frontend editor, or API)
Human-readable stored diff (before/after) rendered so non-technical editors review changes without reading raw XML/QWeb
One-click Restore that writes the selected snapshot back into the live view within a single database transaction
Restore-safety: the pre-restore state is snapshotted first, so any rollback is itself reversible
`@api.depends` compute field exposing current revision number and last editor directly on the page form view
Group-separated permissions via `ir.model.access.csv` + record rules — view-history vs. perform-restore granted independently
Retention policy configured in `res.config.settings`: keep last N revisions and/or prune by age through a scheduled `ir.cron` job
Optional coverage of associated menus, SEO metadata, field translations (`ir.translation`) and attachments, selectable per scope
OWL-based revision timeline reachable from the frontend website editor toolbar, or backend-only, per configuration
Full audit-trail logging of every restore for governance and change accountability
XML-RPC / JSON-RPC endpoints to list, read, diff and restore revisions from external release/governance tooling
Upgrade-safe implementation via `write()`/`create()` overrides — no core patching — validated on Odoo 17.0, 18.0 and 19.0, Community and Enterprise

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

Anyone who edits Odoo website pages knows the cold-sweat moment: an editor drags a snippet into the wrong place, someone overwrites a carefully-tuned hero section, or a bulk find-and-replace mangles copy across a landing page — and the native website builder has no meaningful undo once the record is saved. Out of the box, website.page and its backing ir.ui.view store only the current arch_db; earlier states vanish the moment you save. There is no per-page timeline, no diff, no "who changed what and when," and no safe rollback. Teams end up keeping shadow copies in documents or restoring an entire database from a nightly backup just to recover one paragraph — an expensive, disruptive sledgehammer for a small mistake.

This is exactly where Odoo native runs out of road, and the gap we build to fill. ECOSIRE builds a made-to-order module that snapshots the arch_db of a website page (and, where in scope, its associated ir.ui.view records, menu entries and SEO metadata) on every save, storing each snapshot as an immutable row on a dedicated website.page.revision model. Each revision captures the author (create_uid), a timestamp, an optional change note, and a stored diff so a non-technical editor sees a human-readable before/after without reading XML. A one-click Restore action writes the chosen snapshot back into the live view inside a single transaction, and — because Restore is itself a save — the pre-restore state is snapshotted first, so a restore can always be undone.

Technically, the module hooks the write path with a write() override (and an @api.model create hook) on ir.ui.view/website.page, computing a content hash so identical saves do not create noise revisions. A @api.depends-driven compute field surfaces the current revision number and last editor on the page form. Access is governed by ir.model.access.csv plus record rules so that viewing history, and the more sensitive Restore action, can be granted to distinct groups (e.g. an editor can view but only a website manager can roll back); every restore writes to the audit trail. Optional configuration — exposed through res.config.settings — controls retention (keep last N revisions, or prune by age via a scheduled ir.cron automated action), whether snapshots also cover attachments and translations (ir.translation / field translations), and whether the timeline is reachable from the frontend editor toolbar via an OWL component or only from the backend. All read/restore operations are available over the standard XML-RPC/JSON-RPC API for integration with your release or governance tooling. It is built and tested against Odoo 17.0, 18.0 and 19.0, works on Community and Enterprise (the website app is Community-grade, so no Enterprise dependency is imposed), and ships as clean, upgrade-safe source.

Because this is build-to-order, delivery follows a short, predictable path: a scoping call to lock exactly which records and metadata are versioned and who may restore, a fixed written quotation, then build and unit testing, UAT on a staging copy of your database, and go-live with a rollback plan. Typical delivery is one working week from confirmed scope. Pricing starts from $999 (indicative, single-company base scope); wider snapshot coverage (translations, attachments, multi-website or multi-company record rules), deeper diff/rendering work, or migration of an existing edit-history dataset increases the quoted scope. You receive a firm fixed price after the scoping call — never a surprise.

What you get

  • Installable, upgrade-safe source code for your version of the module (clean `__manifest__.py`, models, views, security files)
  • Installation and configuration on your Odoo environment, including retention and permission setup
  • Technical documentation: data model, `write()`/cron hooks, security matrix, and API reference
  • End-user guide plus a live training session for editors and website managers
  • UAT on a staging copy of your database with a documented sign-off checklist and rollback plan
  • Post-go-live support window (bug fixes and adjustments) for the agreed period after launch
  • Git repository handover with full commit history and tagged release for your version(s)
  • Compatibility validation notes across the Odoo version(s) in your scope (17.0 / 18.0 / 19.0)

Who this is for

Website / Marketing Manager

Owns the public Odoo website and runs frequent landing-page and campaign edits. Needs a safety net so a bad edit or a departing contractor's mistake can be reverted in seconds instead of restoring a whole database backup.

Odoo Administrator / Internal IT

Responsible for database integrity and change governance. Wants an auditable trail of who changed which page and when, retention controls to keep the table lean, and record rules so only trusted roles can perform a restore.

Digital Agency Managing Client Odoo Sites

Edits many pages across client instances and hands work between team members. Needs per-page version history and diffs to review changes, plus one-click rollback to recover from editor errors without escalating to the client's IT.

Compliance / Operations Lead

Needs demonstrable change control over public-facing content for regulatory or brand-governance reasons. Values the immutable revision log, author attribution, and the ability to prove and reverse any published change.

How Website Page Restore, Revision & History Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Page-level revision historyFull timeline per page, built to your scopePossible but you design the model from scratchFixed feature set, take-it-or-leave-itNone — only the current `arch_db` is stored
One-click restoreTransactional restore, itself reversibleDepends entirely on your build effortUsually present but not tailoredAbsent — restore means a full DB backup restore
Change diff / before-afterHuman-readable stored diff for editorsYou implement and maintain the diff logicMay show raw XML or none at allNone
Permissions & auditSeparate view/restore groups + full audit logYour responsibility to design securelyGeneric, rarely group-separatedNo history-specific access control
Retention controlKeep-N or prune-by-age via `ir.cron`Build and test the cron yourselfFixed or missing retention optionsN/A
Fit to your Odoo setupScoped to your records, versions & workflowFully bespoke but slow and costly to reachGeneric; you adapt to its assumptionsN/A
Support & ownershipSupport window + git repo handoverIn-house team must own it long-termVendor support, no source ownershipCore Odoo support only
Odoo 17/18/19 + editionBuilt & tested per your version, CE or EEYou port and retest across versionsVaries; may lag new releasesN/A

Frequently Asked Questions about Website Page Restore, Revision & History

Is this an app I can download and install today?

No. This is a build-to-order module. ECOSIRE designs, builds, installs and supports it for your specific Odoo environment after a scoping call. It is not an existing apps.odoo.com download, and we never claim an instant install.

How long does delivery take?

Typical delivery is one working week from confirmed scope. The timeline starts once we have agreed in writing exactly which records and metadata are versioned, who may restore, and your target Odoo version(s). Larger scope — extra coverage, migrations, multi-company rules — can extend it, and we state the timeline in your fixed quote.

How does pricing and scoping work?

Pricing starts from $999 (indicative, single-company base scope). We hold a short scoping call to confirm requirements, then send a firm fixed-price quotation — no open-ended hourly billing. Drivers such as translation/attachment coverage, multi-website or multi-company record rules, deeper diff rendering, or migrating an existing edit-history dataset increase the quoted scope.

What Odoo versions and editions are supported?

We build and test against Odoo 17.0, 18.0 and 19.0. The module targets the website app, which is Community-grade, so it runs on both Community and Enterprise and imposes no Enterprise dependency. You tell us your version(s) at scoping and we deliver source built for them.

What happens after go-live — support and updates?

Every engagement includes a post-go-live support window for bug fixes and adjustments, agreed in the quote. You also receive the git repository so your team owns the code. Beyond the included window, we offer optional ongoing support and version-upgrade work (for example when you move to a newer Odoo release) under a separate agreement.

Will it slow down page saves or bloat the database?

Snapshots are lightweight `arch_db` rows with content-hash de-duplication, so identical saves create no revision. Retention is configurable — keep the last N revisions or prune by age via a scheduled `ir.cron` job — so the history table stays bounded. We tune both during scoping to match your edit volume.

Can a restore itself be undone if we roll back to the wrong version?

Yes. A Restore is treated as a save, so the current state is snapshotted before the chosen revision is written back. If you restore the wrong version, the immediately-prior state is still in the timeline and one click away, all inside audited transactions.

Request a quote

Website Page Restore, Revision & History

A build-to-order Odoo module that captures a full revision history for every website page, letting your team compare versions, roll back mistakes, and restore any prior state with one click. ECOSIRE designs, builds, installs, and supports it after a scoping call — it is not an instant download.

  • Automatic `arch_db` snapshot of each website page on every save, stored as immutable `website.page.revision` rows keyed to the `ir.ui.view`
  • Content-hash de-duplication so identical or no-op saves do not generate noise revisions
  • Per-revision metadata: author (`create_uid`), timestamp, optional change note, and originating source (backend, frontend editor, or API)
  • Human-readable stored diff (before/after) rendered so non-technical editors review changes without reading raw XML/QWeb

Request a Quotation

Tell us about your Website Page Restore, Revision & History 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.