Skip to main content
Workspace & Field-Level Permissions Manager — A build-to-order Frappe app that extends ERPNext permissions with field-level r — 1/1Illustrative preview

A build-to-order Frappe app that extends ERPNext permissions with field-level read/write masking,

record-level rules and role-scoped workspace visibility.

ECOSIRE scopes, builds, installs and supports it on your ERPNext v15/v16 bench.

What is Workspace & Field-Level Permissions Manager?

A build-to-order Frappe app that extends ERPNext permissions with field-level read/write masking, record-level rules and role-scoped workspace visibility. ECOSIRE scopes, builds, installs and supports it on your ERPNext v15/v16 bench. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

Role-profile-aware workspace visibility that shows or hides Frappe Workspaces, shortcuts and cards per user without cloning workspaces
Field-level read/write/mask rules driven by a `Field Permission Rule` DocType instead of scattered `permlevel` hacks
Server-side enforcement in `hooks.py` doc events (`validate`, `before_save`, `onload`) so masked values never reach the client
Masking applied at the field-fetch layer so hidden values are also stripped from the Frappe REST API (`/api/resource`, `frappe.client.get`) and report builder
Record-level rules via `get_permission_query_conditions` so filtering happens in the SQL `WHERE` clause, not just in the UI
`has_permission` hook for per-document allow/deny beyond ERPNext's User Permission link matching
User- and group-scoped rules that map to existing role profiles, teams and territory/company dimensions
Private comments and tagged visibility so record notes are seen only by named users or groups
Permission Audit Script/Query Report resolving the effective read/write/mask matrix per user and flagging conflicting rules
Immutable log DocType capturing every rule change and every access-denied event for compliance trails
Scheduled weekly permission-change and access-denial digest via a registered `scheduler_event`
Whitelisted server methods for programmatic rule checks so integrations honour the same access boundary
Client scripts used only for UX (greying masked fields, hiding tabs) with the real boundary always on the server
Delivered as a versioned Frappe app with fixtures and `hooks.py`, upgrade-safe across ERPNext v15 and v16

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 ERPNext.

  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

ERPNext Compatibility
—
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
MariaDB 10.6+

About this Product

Standard ERPNext permissions are role-and-DocType shaped: you grant a role read/write/create/delete on a DocType, add User Permissions to fence off records by link field, and lean on Permission Level (permlevel) fields for coarse column control. That works until Finance can see a customer record but must never see its credit_limit, until a regional manager should only touch leads in their own territory group, or until a whole workspace of reports needs to disappear for contractors. At that point admins resort to duplicating DocTypes, hiding fields with brittle client scripts (which never actually secure the data server-side), or over-granting roles and hoping nobody notices. ERPNext core simply runs out of road for least-privilege, per-field, per-record governance.

We build a proper Frappe app (its own module, DocTypes, hooks.py and fixtures) that layers structured, auditable access control on top of ERPNext's native permission engine rather than fighting it. A Field Permission Rule DocType maps role profiles to per-field read/write/mask behavior; enforcement runs server-side in hooks.py doc events (before_save, validate, onload) and in an override of the controlled DocTypes' get_valid_columns/field-fetch path, so masked values never leave the server even via the Frappe REST API, frappe.client.get, list view, or report builder. Record-level rules are evaluated with a whitelisted get_permission_query_conditions hook and a has_permission hook, so filtering happens in the SQL WHERE clause — a user cannot enumerate hidden records by guessing names or paging the /api/resource endpoint. Workspace visibility is driven by role-profile-aware logic that hides or shows Frappe Workspaces and their shortcuts per user without cloning them.

On top of enforcement we build the operational surface admins actually need: a Permission Audit report (Query/Script Report) that resolves, for any user, the effective read/write/mask matrix across the governed DocTypes and flags conflicts; private comments and tagged-visibility controls so notes on a record are only visible to named users or groups; and a scheduled digest (registered as a scheduler_event) that emails owners a weekly summary of permission changes and access-denied events. Every rule change and every enforced denial is written to a log DocType so you have a defensible trail for audit and compliance reviews. Client scripts are used only for UX affordances (greying out masked fields, hiding tabs) — never as the security boundary, which always lives on the server.

Because this is built-to-order, nothing here is a generic download. We start from your real role profiles, the exact DocTypes and fields you need to govern, and your ERPNext version (v15 or v16), then deliver an app tailored to that scope. Typical delivery is one working week from confirmed scope. You get the installable source code for your build, installation and configuration on your bench, technical and end-user documentation, a training session, UAT on a staging site with a tested rollback plan, and a post-go-live support window. ECOSIRE builds it, installs it, and supports it — you are not left to reverse-engineer someone else's marketplace app.

What you get

  • Installable source code for your build — a versioned Frappe app with module, DocTypes, `hooks.py` and fixtures
  • Installation and configuration on your ERPNext bench, wired to your real role profiles and governed DocTypes
  • Technical documentation covering DocType schema, hook flow, whitelisted methods and how enforcement is applied
  • End-user and admin guide plus a live training session for your permissions administrators
  • UAT on a staging site with a documented, tested rollback plan before production cut-over
  • Post-go-live support window for defect fixes and configuration questions
  • Git repository handover with full commit history and tagged release
  • Seeded example rules and the Permission Audit report configured for your initial governed DocTypes

Who this is for

Security & compliance administrator

Owns least-privilege access and needs field-level masking, record-level scoping and a defensible audit trail that ERPNext core cannot express through roles and User Permissions alone.

ERPNext system administrator

Manages role profiles across Finance, Sales and Operations and wants structured permission rules and an effective-access report instead of duplicated DocTypes and brittle client-script hiding.

Regional or divisional manager

Should only see and edit records within their own territory, company or team, enforced in the query layer so hidden records never surface via list views, reports or the REST API.

Data protection / internal audit lead

Needs proof that sensitive fields (salary, cost, credit limit, PII) are masked server-side and that every permission change and denial is logged for reviews.

How Workspace & Field-Level Permissions Manager Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Field-level maskingServer-side read/write/mask per field via rule DocTypePossible but hand-coded per fieldOften UI-only hiding, not enforcedCoarse `permlevel` only, no true masking
Record-level rulesSQL `WHERE`-level filtering via query hookAchievable with deep Frappe knowledgeUsually limited to link-based filtersLink-based User Permissions only
REST API / report leakageMasked and filtered on API, list and reportsMust remember every access pathFrequently leaks via API or report builderRespects roles but not field masking
Workspace visibilityRole-profile-aware show/hide, no cloningManual per-user workspace jugglingRarely coveredBasic role-based, coarse
Audit & change logEffective-access report + immutable change logBuild it yourselfSeldom includedNo effective-access view
Fit to your orgBuilt to your roles, DocTypes and dimensionsFully bespoke, higher risk/costGeneric, configure to fitConfigure within core limits
Support & handoverPost-go-live window + git repo + docsDepends on the developerVendor forum/ticket, no source accessCommunity support only
Delivery modelBuild-to-order, one working week, UAT + rollbackOpen-ended timelineInstant download, integration on youAlready in your ERPNext

Frequently Asked Questions about Workspace & Field-Level Permissions Manager

How long does delivery take?

This is a build-to-order app, not an instant download. After a scoping call to confirm the exact role profiles, DocTypes, fields and rules you need, typical delivery is one working week from confirmed scope, including UAT on staging before go-live.

How is this different from ERPNext's built-in Role Permissions and User Permissions?

ERPNext core is role-and-DocType shaped with coarse `permlevel` field control and link-based User Permissions. We add per-field read/write/masking, per-record allow/deny evaluated in the SQL query layer, and role-profile-aware workspace visibility — enforced server-side, with an effective-access audit report and change log on top.

Is the masking actually secure, or just hidden in the UI?

It is enforced server-side in `hooks.py` doc events and at the field-fetch layer, so masked values are stripped from the REST API, `frappe.client.get`, list views and report builder — not just greyed out. Client scripts only handle UX affordances; they are never the security boundary.

Which ERPNext and Frappe versions are supported?

We build and test against ERPNext/Frappe v15 and v16. We confirm your exact bench version during scoping and deliver an app aligned to it, with an upgrade-safe structure.

How do support and updates work after go-live?

Every build includes a post-go-live support window for defect fixes and configuration questions. Beyond that, we offer ongoing support and can add rules, DocTypes or version-upgrade compatibility as a follow-on engagement. You also receive the full git repository so your team can maintain it.

Will this survive an ERPNext version upgrade?

Because it is a standalone Frappe app using documented hooks (`get_permission_query_conditions`, `has_permission`, doc events, `scheduler_events`) rather than core patches, it upgrades cleanly. We validate against your target v15/v16 version and hand over docs so upgrades stay predictable.

Can rules follow our existing teams, territories or companies?

Yes. Record-level rules can key off existing dimensions such as territory, company, department or custom group fields, mapped to your current role profiles, so access mirrors your real org structure without duplicating records or roles.

Request a quote

Workspace & Field-Level Permissions Manager

A build-to-order Frappe app that extends ERPNext permissions with field-level read/write masking, record-level rules and role-scoped workspace visibility. ECOSIRE scopes, builds, installs and supports it on your ERPNext v15/v16 bench.

  • Role-profile-aware workspace visibility that shows or hides Frappe Workspaces, shortcuts and cards per user without cloning workspaces
  • Field-level read/write/mask rules driven by a `Field Permission Rule` DocType instead of scattered `permlevel` hacks
  • Server-side enforcement in `hooks.py` doc events (`validate`, `before_save`, `onload`) so masked values never reach the client
  • Masking applied at the field-fetch layer so hidden values are also stripped from the Frappe REST API (`/api/resource`, `frappe.client.get`) and report builder

Request a Quotation

Tell us about your Workspace & Field-Level Permissions Manager 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.