Skip to main content
Hide Create — A build-to-order Odoo module that removes Create, Delete, Archive, Duplicate and Export controls from the UI fo — 1/1Illustrative preview

A build-to-order Odoo module that removes Create, Delete,

Archive, Duplicate and Export controls from the UI for the user groups you choose, enforced at both the view and ORM layer so the restriction can't be worked around.

ECOSIRE scopes, builds, installs and supports it for your database.

What is Hide Create?

A build-to-order Odoo module that removes Create, Delete, Archive, Duplicate and Export controls from the UI for the user groups you choose, enforced at both the view and ORM layer so the restriction can't be worked around. ECOSIRE scopes, builds, installs and supports it for your database. 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

Per-group, per-model rules for four UI actions: Create, Delete (unlink), Archive/Unarchive, and Export, configurable without editing XML
Optional Duplicate (copy) suppression on form views for groups that must not clone records
Dual enforcement: view-layer `create`/`delete`/`edit`/`export_xlsx` flags plus ORM-level `create()`/`unlink()`/`write()` overrides that raise `AccessError`
API-safe by design: blocked actions are also rejected over JSON-RPC and XML-RPC, not just hidden in the web client
`get_view`/`fields_view_get` override that rewrites the arch per user group so different groups see different buttons on the same view
Archive control targets the `active` field write path, so record-rule-based hiding and the Archive menu stay consistent
Export lockdown removes the list-view Export action and blocks the underlying `export_data`/xlsx route for scoped groups
Configuration model with a settings screen: pick model via `ir.model`, pick group via `res.groups`, toggle each action
Super-user and `base.group_no_one` handling made explicit during scoping so admins are never accidentally locked out
Multi-company aware: rules can respect `company_id` context and coexist with existing `ir.rule` record rules
Clear, translatable block messages (e.g. `You are not allowed to export records from this list`) rather than silent failures
Works alongside standard `ir.model.access.csv` and record rules without replacing your existing security matrix
Compatible with tree, form and kanban views, including inherited and Studio-generated views identified during scoping
Audit-friendly: blocked attempts surface as `AccessError` in the logs so security reviews can confirm enforcement

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

Odoo's stock access model is coarse. ir.model.access.csv grants a group read/write/create/unlink on a whole model, and record rules scope which rows they touch, but neither lets you keep write access while stripping only the Create button, only the Delete action, or only the CSV/XLSX export from a list view. In practice teams need exactly that granularity: a warehouse clerk who can edit stock moves but must never create ad-hoc records, an accountant who can update invoices but must not archive or export the master ledger, a support agent who edits tickets but cannot mass-delete. When Odoo native runs out of road, most teams resort to fragile per-model view overrides or over-restrict with perm_unlink=0 and break legitimate edit flows.

Hide Create is a build-to-order Odoo module that gives you surgical, per-group control over the four dangerous UI actions, Create, Delete (unlink), Archive/Unarchive, and Export, plus Duplicate where you need it, targeted at exactly the models and user groups you specify. We drive it from a small configuration model so you manage rules from a settings screen rather than editing XML: pick a model, pick a security group, and toggle which action buttons disappear for members of that group. Under the hood we combine two enforcement layers so a hidden control cannot simply be re-enabled by a power user. In the views we inject the relevant create, delete, edit and export_xlsx option flags on the tree/form/kanban nodes (via inherited ir.ui.view arch or an fields_view_get/get_view override that adapts the arch to the current user's groups). In the ORM we override create(), unlink(), write() (for the active/archive field) and the export path so a blocked action raises AccessError even if triggered through the JSON-RPC/XML-RPC API, an imported list, or a crafted URL, closing the gap that view-only hiding leaves open.

Because every Odoo database has a different mix of models, groups and edge cases, we build this to order rather than shipping a one-size configuration. We start with a short scoping call to map which models, which groups, and which of the four actions each combination should lose, then confirm whether super-users, base.group_no_one and portal users are in or out of scope. We develop against a copy of your models, respecting your Community or Enterprise edition and targeting Odoo 17.0, 18.0 or 19.0, ship the module with its own __manifest__.py, security rules and configuration data, and validate on a staging database before touching production. Typical delivery is one working week from confirmed scope depending on how many model/group combinations and non-standard views are involved.

Pricing starts from $999 (indicative, single-company base scope); wider model and group coverage, custom studio or third-party models, multi-company record-rule interplay, and deeper localization of blocked-action messages increase the quoted scope. You get a fixed quote after the scoping call, never a surprise invoice.

What you get

  • Installable module source code for your Odoo version (17.0, 18.0 or 19.0), with `__manifest__.py`, models, security and configuration data
  • Installation and configuration on your staging environment, plus a guided production install
  • Technical documentation covering the configuration model, enforcement layers and how to add new model/group rules
  • End-user and administrator guide plus a live training session for your team
  • UAT on a staging database with a documented rollback plan before any production change
  • Post-go-live support window for bug fixes and configuration adjustments
  • Git repository handover with full commit history and tagged release
  • Compatibility notes for your edition (Community vs Enterprise) and any Studio or third-party models in scope

Who this is for

ERP / Odoo administrator

Owns the security matrix and is tired of maintaining per-model view overrides. Needs a single, configurable place to strip Create/Delete/Archive/Export from specific groups without giving up their existing `ir.model.access.csv` and record rules.

Compliance and internal-controls lead

Must prove separation of duties and prevent bulk data exfiltration. Needs export and delete locked down for operational staff and enforced at the API layer, with blocked attempts visible in logs for audit.

Operations / warehouse or finance manager

Wants front-line staff to edit day-to-day records but never create rogue entries, archive master data, or export customer and ledger lists. Needs button-level restrictions that match real job roles.

Odoo implementation partner or in-house dev team

Delivering a rollout and needs granular action hiding done cleanly, with source and docs handed over, rather than accumulating brittle one-off view patches across many models.

How Hide Create Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Action granularityPer-group toggle for Create, Delete, Archive, Export and DuplicateWhatever you code, if budget and time allowFixed set of toggles, often global not per-groupWhole-model create/unlink flags only, no per-button control
Enforcement depthView flags plus ORM overrides, blocks API calls tooDepends on developer disciplineUsually view-only hiding, bypassable via APIReal at ORM level but only at model granularity
Export lockdownRemoves Export action and blocks the xlsx/export routeBuildable but frequently overlookedSometimes hides the button but not the routeNo selective export restriction by group
Fit to your databaseScoped to your models, groups and editionFully bespoke but you own all the effortGeneric, you adapt your setup to itGeneric core behavior
Setup effort for youWe scope, build, install and validate on stagingYour team designs, builds and tests it allSelf-install and self-configureManual CSV and record-rule editing per model
Support and handoverDocs, training, support window and git repo handoverOnly what you resource internallyVendor support varies, often community-onlyNo product support, community forums only
Version coverageBuilt and tested for 17.0, 18.0 or 19.0You maintain each version yourselfDepends on vendor's version matrixTied to your installed Odoo version
Total cost profileFixed quote from indicative $999 after scopingOpen-ended developer timeLow sticker price, hidden config and gap-filling costFree but manual and limited

Frequently Asked Questions about Hide Create

Is this an app I can download and install right now?

No. Hide Create is build-to-order. We scope it to your models, groups and edition, then build, install and support it for your database. It is not an off-the-shelf instant download, and we never claim it already exists as a shipped product.

How long does delivery take?

Typically one working week from confirmed scope. The exact timeline depends on how many model and group combinations are in scope and how many non-standard or Studio views need handling. We confirm the delivery date in writing after the scoping call.

How does pricing and scoping work?

Pricing starts from an indicative $999 for a single-company base scope. After a short scoping call we give you a fixed quote. Wider model/group coverage, multi-company record-rule interplay, custom or third-party models, and deeper message localization increase the quoted scope. There is no surprise invoice, you approve the fixed quote before we build.

Can a technical user just re-enable the buttons?

No. We enforce restrictions in two layers. The views hide the controls, and the ORM overrides on `create()`, `unlink()`, `write()` and the export path raise an `AccessError` even if the action is triggered through the JSON-RPC/XML-RPC API or a crafted request, so hiding is not the only line of defense.

What about support and updates after go-live?

Every build includes a post-go-live support window for bug fixes and configuration tweaks, and we hand over the git repository so your team can maintain it. We can also quote a separate maintenance agreement to cover future Odoo version upgrades (for example 18.0 to 19.0) and new model/group rules as your needs change.

Does it work with Odoo Community or Enterprise?

Both. We confirm your edition during scoping because some views and features differ between Community and Enterprise, and we target the enforcement to what your edition actually renders. We support Odoo 17.0, 18.0 and 19.0.

Will it break my existing access rights and record rules?

No. It works alongside your existing `ir.model.access.csv` entries and `ir.rule` record rules rather than replacing them. It only adds button-level and action-level restrictions on top, and we validate the combined behavior on staging during UAT before production.

Request a quote

Hide Create

A build-to-order Odoo module that removes Create, Delete, Archive, Duplicate and Export controls from the UI for the user groups you choose, enforced at both the view and ORM layer so the restriction can't be worked around. ECOSIRE scopes, builds, installs and supports it for your database.

  • Per-group, per-model rules for four UI actions: Create, Delete (unlink), Archive/Unarchive, and Export, configurable without editing XML
  • Optional Duplicate (copy) suppression on form views for groups that must not clone records
  • Dual enforcement: view-layer `create`/`delete`/`edit`/`export_xlsx` flags plus ORM-level `create()`/`unlink()`/`write()` overrides that raise `AccessError`
  • API-safe by design: blocked actions are also rejected over JSON-RPC and XML-RPC, not just hidden in the web client

Request a Quotation

Tell us about your Hide Create 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.