A build-to-order ERPNext application for manned-guarding companies: define client sites and post requirements, roster guards and reliefs, capture patrol and incident logs from the field, and turn verified attendance into payroll input and contract invoices. ECOSIRE scopes, builds, installs and supports it — it is not an instant download. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $499.00 USD; request a quote for a scoped proposal.
Illustrative previewA build-to-order ERPNext application for manned-guarding companies:
define client sites and post requirements, roster guards and reliefs, capture patrol and incident logs from the field, and turn verified attendance into payroll input and contract invoices.
ECOSIRE scopes, builds, installs and supports it — it is not an instant download.
No DIY setup — a working app, built, installed and supported by ECOSIRE.
Start with a one-time build price. We scope it with you at kickoff.
ECOSIRE builds, configures and installs it on your ERPNext.
You go live in about 2–4 weeks, with a post-launch support window.
A guarding company does not sell products, it sells covered hours at a post. The operations reality is that a client site has three posts, one of which is 24x7 on a two-shift pattern, another is nights only, and the third is armed and requires a specific licence class. A guard calls in sick at 22:40 and a reliever has to be found who is licence-valid, not already on duty, and not about to breach a weekly hours cap. At month end, finance has to invoice the client for exactly what was covered — including the double-time public holiday shift and minus the four hours nobody turned up for — and pay the guards from the same underlying attendance. Stock ERPNext has none of this shape. There is no DocType that means "a post that must be manned from 19:00 to 07:00 by a guard holding licence class B". Shift Type and Shift Assignment model an employee's working pattern, not a customer-facing coverage obligation; Attendance is a per-employee day record with no link to a client site or a billable contract line; and the Employee doctype has nowhere to hold licence numbers with expiry dates that must block rostering. Companies end up running the roster in a spreadsheet, the patrol log on WhatsApp, and the invoice by hand — and the three never reconcile.
What ECOSIRE builds is a proper Frappe app (its own repo, its own module, installed with bench get-app and bench --site ... install-app) that sits on top of ERPNext rather than forking it. The core DocTypes are Guard Site (the client location, linked to the ERPNext Customer), Guard Post (a child-table-driven set of coverage requirements per site: post name, days, start and end time, headcount, required licence class, armed/unarmed, billing rate reference), Guard Roster (a period-scoped plan that generates Roster Shift rows for every post-day in the range), Roster Shift (one guard, one post, one dated shift, with status draft/published/confirmed/covered/uncovered), Relief Request (an open shift plus the reason and the replacement decision), Patrol Checkpoint and Patrol Log, and Security Incident with a severity workflow and attachments. Guard licences live in a Guard Credential child table on Employee with an expiry_date, so validation is data, not tribal knowledge.
The logic lives where Frappe expects it. A validate hook on Roster Shift rejects an assignment when the guard has an overlapping shift, an expired or missing credential for the post's required class, or would exceed the configured weekly-hours or consecutive-nights limit — each check is an individual frappe.throw so the planner sees exactly which rule bit. hooks.py doc_events on Attendance and on the app's own Duty Confirmation keep the roster and the attendance record in agreement, and on_submit of the shift period writes the Attendance rows ERPNext payroll already reads, so Salary Slip generation via the standard Payroll Entry works with no parallel payroll engine. Billing is generated from the same verified rows: a server-side method rolls covered hours per site and per rate band into a draft Sales Invoice with one item line per post and per band, honouring the customer's contract rates held on a Guard Service Contract DocType, so a shortfall in coverage is visibly credited rather than silently invoiced. Field capture is over the Frappe REST API and whitelisted methods (@frappe.whitelist()), so a supervisor's phone or an existing NFC/QR patrol device can post a checkpoint scan with a timestamp and geolocation; a scheduler_events hourly job flags checkpoints that were due and never scanned, and a daily job raises credential-expiry warnings 30/14/7 days out. Client scripts add the roster grid's colour-coded coverage view and the one-click relief search. Role profiles separate Operations Manager (publish rosters, approve reliefs), Site Supervisor (patrol and incident entry for assigned sites only, enforced with a user-permission-backed get_permission_query_conditions hook), Payroll, and Accounts — a supervisor cannot see another client's sites, and cannot touch a rate.
Everything is built against Frappe/ERPNext v15 and v16, and we build for the version you actually run — we do not ship a v14 app with a compatibility note. Optional extensions we regularly scope alongside the core: geofenced clock-in, overtime and public-holiday rate rules, subcontracted-guard cost tracking, a client portal page where the customer can see their own coverage and incident reports, and export files for a specific national licensing regulator.
This is build-to-order, and we are explicit about what that means. There is no ZIP to download today. You book a scoping call, we walk your actual sites, shift patterns, rate cards and licensing rules, and we come back with a fixed scope and a fixed price. Typical delivery is two to four weeks from confirmed scope for a core build, longer if the scope includes a mobile field client or an integration with a third-party access-control or biometric system. We build on a staging bench, you run UAT there against your own data, and only then do we install on production with a documented rollback. You receive the git repository — the code is yours, and you are never locked to us to maintain it.
Runs 200 to 2,000 guards across dozens of client sites and knows margin is being lost between what was rostered, what was actually covered, and what was invoiced. Wants one system where the roster, the attendance and the client invoice are the same data, and wants to own the code rather than rent a black box.
Lives in the roster. Needs to see uncovered posts for tonight at a glance, find a licence-valid reliever in under a minute at 23:00, and be prevented — not merely warned — from assigning a guard whose licence expired last week or who is already on duty elsewhere.
Has to invoice each client to their specific contract rate card, with the right premiums for nights, holidays and armed posts, and to credit coverage that was never delivered before the client's own audit finds it. Wants the invoice generated from verified duty records, not retyped from a spreadsheet.
Answerable for licence validity, working-time limits and the evidence trail when a regulator or a client audits a site. Needs credential expiry surfaced ahead of time, hours caps enforced at data entry, and payroll driven by the same attendance records the client was billed against.
| Criterion | ECOSIRE | Custom Build | Competitor | ERPNext Native |
|---|---|---|---|---|
| Fit to your shift patterns, rate cards and licensing rules | Built to your actual rules after a scoping call; validation logic written for your hours caps and licence classes | Also a perfect fit, if your developer understands both guarding operations and Frappe conventions | Fits the author's assumed market; local licensing and premium rules usually need forking | No concept of a client post, a licence class or a coverage obligation exists in ERPNext core |
| Time to a working system | Typically 2 to 4 weeks from confirmed scope for a core build; larger scopes quoted with a real date | Months, plus the discovery time your team spends teaching the developer the domain | Installs in an afternoon; then weeks of workarounds where it does not match your operation | Immediate, but you are running the roster in a spreadsheet on day one and forever |
| Payroll and accounting integration | Writes standard ERPNext `Attendance`; `Payroll Entry` and `Sales Invoice` work unchanged | Depends entirely on discipline — in-house builds often grow a parallel payroll engine that drifts | Usually integrates with ERPNext payroll, but billing to contract rate bands is commonly absent | Payroll works; nothing connects it to client sites, coverage or contract billing |
| Code ownership | Private git repository handed over with full history; you can maintain or extend it with any team | You own it, and you also own every undocumented decision the original developer left behind | Vendor-owned; you depend on their roadmap and release cadence for every change | Frappe/ERPNext is open source, but the guarding functionality does not exist to own |
| Version support and upgrade path | Built for the v15 or v16 you actually run; a separate app, so ERPNext point upgrades stay routine | Upgrade cost lands on you each cycle, and untested apps break quietly on a major version | Support depends on whether the author still maintains it for your version | Upgrades are clean because there is nothing extra — and nothing solved |
| Field capture (patrols, incidents, duty confirmation) | REST API and whitelisted methods; phone browser, QR/NFC tags, or an integration with your existing trackers | Buildable, but the API surface and permission model are where DIY builds most often go wrong | Often ships a mobile app, sometimes with per-guard licence fees on top | None — patrol evidence lives in WhatsApp messages and paper occurrence books |
| Permissions and client data separation | Role profiles plus server-side `get_permission_query_conditions`; supervisors see only their sites, never rates | Frequently UI-only hiding, which leaks the moment someone opens a report or the API | Generic role setup; per-site restriction and rate-field masking usually need customisation | Standard Frappe permissions exist, but there are no site or post records to scope them to |
| Cost shape and risk | Fixed scope, fixed price, UAT on staging with a rollback plan before the production install | Open-ended day rate with the domain-learning curve billed to you | Low licence cost; the real cost appears later as workarounds and manual reconciliation | No software cost; the cost is the margin lost between rostered, covered and invoiced hours |
No — this is build-to-order, not a marketplace download. You book a scoping call, we agree a fixed scope and price, and typical delivery is two to four weeks from confirmed scope for a core build (sites, posts, rostering, patrol and incident logs, attendance and contract billing). A larger scope — a dedicated mobile field client, geofencing, or integration with third-party access-control, biometric or GPS-tracker systems — takes longer, and we give you a realistic date in writing before you commit.
We build against Frappe/ERPNext v15 and v16 and target the exact version your bench runs — we do not ship an older app with a compatibility disclaimer. Because it is a separate Frappe app that extends ERPNext through DocTypes, hooks and custom fields rather than patching core files, an ERPNext point upgrade is normally uneventful. A major version jump is a scoped piece of work; the technical documentation includes an upgrade section, and since you hold the git repository your own team can do it if you prefer.
Every build includes a post-go-live support window — typically 30 to 90 days depending on scope — during which defects in the delivered functionality are fixed at no extra cost, by a named engineer, with fixes delivered as commits to your repository. After that you can take an annual support and enhancement retainer, or maintain it yourself: you own the code and the repo, so nothing is locked. New features requested after sign-off are quoted as a change rather than silently absorbed or refused.
No, and deliberately so. Duty confirmations write standard ERPNext `Attendance` records, so `Payroll Entry`, `Salary Structure` and `Salary Slip` work exactly as ERPNext ships them, with your existing salary components, statutory deductions and leave policy intact. What we add is the guarding-specific layer ERPNext has no concept of: a client-facing post that must be manned, licence-gated assignment, reliefs, patrols and coverage-based billing.
Patrol scans, incident reports and duty confirmations are posted through the Frappe REST API and whitelisted methods, so a supervisor's phone browser works out of the box, and existing QR or NFC patrol tags can be read with any scanner app that can open a URL. If you already run GPS trackers or a third-party guard-tour device, we scope an integration against its API. A dedicated offline-capable mobile app is possible but is a separate, larger piece of work — we will tell you what it costs rather than imply it is included.
Yes. Access is enforced server-side, not just hidden in the UI: role profiles separate Operations Manager, Site Supervisor, Payroll and Accounts, and `get_permission_query_conditions` and `has_permission` hooks restrict a supervisor's list, report and API queries to their assigned sites. Contract rate fields are permission-level restricted so operations staff can roster without ever seeing what the client pays or what the guard earns.
That is exactly what the scoping call is for. Rotation patterns, hours caps, consecutive-night limits, licence classes, overtime and holiday premium rules, and any regulator export format are configuration and validation rules we write to your reality, not fixed assumptions baked into a generic app. Bring your actual rate card, a real roster week and a sample client contract to the call and we will confirm what fits as configuration and what needs building.

A finite-capacity, constraint-aware production scheduler for ERPNext that turns Work Orders and Job Cards into a live, drag-and-drop Gantt plan respecting machine, labor, and material availability. Built to order, installed, and supported by ECOSIRE.

A build-to-order ERPNext app for commercial farms and agribusiness that turns crop cycles, land plots, input usage, and harvest yields into structured DocTypes and traceable records. ECOSIRE scopes, builds, installs, and supports it — it is not an instant download.

A build-to-order Frappe app that captures supplier invoices, receipts, and POs via AI/OCR and turns them into draft ERPNext Purchase Invoices and Expense Claims — with line-item, tax, supplier, and item auto-matching. ECOSIRE scopes, builds, installs, and supports it for you.

A build-to-order AI layer for ERPNext manufacturing that predicts asset failures, recommends optimal production schedules, and surfaces quality anomalies from your Work Order, Job Card, and machine sensor data. ECOSIRE builds, installs, and supports it on your v15/v16 bench.
A build-to-order ERPNext application for manned-guarding companies: define client sites and post requirements, roster guards and reliefs, capture patrol and incident logs from the field, and turn verified attendance into payroll input and contract invoices. ECOSIRE scopes, builds, installs and supports it — it is not an instant download.