Skip to main content
Product details are displayed in English. Translations coming soon.
Security Guard Services Management — A build-to-order ERPNext application for manned-guarding companies: define client sites  — 1/1उदाहरणात्मक पूर्वावलोकन

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.

Security Guard Services Management क्या है?

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 $999.00 USD; request a quote for a scoped proposal.

प्रमुख सुविधाएँ

`Guard Site` and `Guard Post` DocTypes linked to the ERPNext `Customer`, with a child table of coverage requirements: days, start/end time, headcount, armed/unarmed, and required licence class per post
`Guard Roster` generation that expands every post-day in a period into individual `Roster Shift` records, including overnight shifts that cross midnight and configurable rotation patterns (4-on/4-off, 2-2-3, nights-only)
`validate` hooks on `Roster Shift` that block double-booking, missing or expired credentials for the post's required class, and breaches of configured weekly-hours or consecutive-night limits — each as a distinct `frappe.throw` message
`Guard Credential` child table on `Employee` holding licence number, class, issuing authority and `expiry_date`, with a daily `scheduler_events` job raising 30/14/7-day expiry warnings and flagging shifts that would use a lapsed licence
`Relief Request` workflow for no-shows and sick calls: an eligibility-filtered replacement search (credential-valid, not already rostered, within hours cap) exposed as a whitelisted method and a client-script one-click assign
`Patrol Checkpoint` and `Patrol Log` DocTypes with QR/NFC tag identifiers, geolocation and timestamp capture, posted over the Frappe REST API so existing field devices or a phone browser can write directly
Hourly scheduler job that detects missed patrol rounds — checkpoints due within a shift window that were never scanned — and raises an exception record against the shift and its supervisor
`Security Incident` DocType with a severity-driven Frappe Workflow (Reported to Under Review to Closed), file attachments, a client-visibility flag, and per-site notification recipients
Duty confirmation that writes standard ERPNext `Attendance` rows on submit, so `Payroll Entry` and `Salary Slip` generation run unchanged — no parallel payroll engine to reconcile
Contract billing from verified coverage: a `Guard Service Contract` holds per-post and per-rate-band client rates, and a server-side roll-up builds a draft `Sales Invoice` with one line per post and band, crediting uncovered hours instead of invoicing them
Rate bands for overtime, night differential, public holidays and armed-post premiums, applied consistently to both the payroll input and the customer invoice from one rule set
Role profiles for Operations Manager, Site Supervisor, Payroll and Accounts, with `get_permission_query_conditions` and `has_permission` hooks so a supervisor sees only their assigned sites and never a rate card
Coverage dashboard and Query Reports: filled vs unfilled posts by site and date, guard utilisation and hours-to-cap, incident counts by site and severity, and month-to-date billable vs paid hours variance
Built and tested against Frappe/ERPNext v15 and v16, packaged as a standard Frappe app installable with `bench get-app` on your own bench, a Frappe Cloud private bench, or a self-hosted server

ऑर्डर पर निर्मित, पूरी तरह आपके लिए तैयार

स्वयं सेटअप की ज़रूरत नहीं — ECOSIRE द्वारा निर्मित, इंस्टॉल और समर्थित एक कार्यशील ऐप।

  1. 1

    आप ऑर्डर करते हैं

    एक बार के निर्माण मूल्य से शुरू करें। किकऑफ़ पर हम आपके साथ मिलकर दायरा तय करते हैं।

  2. 2

    हम बनाते और इंस्टॉल करते हैं

    ECOSIRE इसे आपके ERPNext पर बनाता, कॉन्फ़िगर और इंस्टॉल करता है।

  3. 3

    लाइव + समर्थन

    आप लगभग एक कार्य सप्ताह में लाइव हो जाते हैं, गो-लाइव के बाद दो सप्ताह के समर्थन के साथ। हमारे द्वारा दिए गए कोड की खामियाँ निःशुल्क ठीक की जाती हैं।

तकनीकी विनिर्देश

ERPNext संगतता
—
लाइसेंस
लाइसेंस की पुष्टि आवश्यक है
Python आवश्यकता
Python 3.10+
डेटाबेस
MariaDB 10.6+

इस उत्पाद के बारे में

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 one working week 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.

What you get

  • Installable Frappe app source code built for your exact Frappe/ERPNext version (v15 or v16), packaged as a standard app with `hooks.py`, fixtures and patches
  • Installation and configuration on your bench or server, including role profiles, workflows, custom fields, naming series and the initial site/post/contract data load
  • Technical documentation: DocType and field reference, hook and scheduler-event map, whitelisted API method reference with request/response examples, and the permission model
  • End-user guide plus a live training session for operations, supervisors and finance, recorded so you can onboard new staff later
  • UAT on a staging bench with your own data, a signed-off acceptance checklist, and a documented rollback plan before the production install
  • Post-go-live support window (defect fixes on the delivered scope, agreed in the contract — typically 30 to 90 days) with a named engineer
  • Handover of the private git repository with full commit history, so the code is yours and you are free to maintain or extend it with any team
  • Version-upgrade guidance covering what changes when you move the underlying ERPNext version

Who this is for

Owner or Managing Director of a manned-guarding company

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.

Operations Manager / Control Room Supervisor

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.

Contracts and Billing Manager

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.

HR / Payroll and Compliance Officer

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.

How Security Guard Services Management Compares

CriterionECOSIRECustom BuildCompetitorERPNext नेटिव
Fit to your shift patterns, rate cards and licensing rulesBuilt to your actual rules after a scoping call; validation logic written for your hours caps and licence classesAlso a perfect fit, if your developer understands both guarding operations and Frappe conventionsFits the author's assumed market; local licensing and premium rules usually need forkingNo concept of a client post, a licence class or a coverage obligation exists in ERPNext core
Time to a working systemTypically one working week from confirmed scope for a core build; larger scopes quoted with a real dateMonths, plus the discovery time your team spends teaching the developer the domainInstalls in an afternoon; then weeks of workarounds where it does not match your operationImmediate, but you are running the roster in a spreadsheet on day one and forever
Payroll and accounting integrationWrites standard ERPNext `Attendance`; `Payroll Entry` and `Sales Invoice` work unchangedDepends entirely on discipline — in-house builds often grow a parallel payroll engine that driftsUsually integrates with ERPNext payroll, but billing to contract rate bands is commonly absentPayroll works; nothing connects it to client sites, coverage or contract billing
Code ownershipPrivate git repository handed over with full history; you can maintain or extend it with any teamYou own it, and you also own every undocumented decision the original developer left behindVendor-owned; you depend on their roadmap and release cadence for every changeFrappe/ERPNext is open source, but the guarding functionality does not exist to own
Version support and upgrade pathBuilt for the v15 or v16 you actually run; a separate app, so ERPNext point upgrades stay routineUpgrade cost lands on you each cycle, and untested apps break quietly on a major versionSupport depends on whether the author still maintains it for your versionUpgrades 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 trackersBuildable, but the API surface and permission model are where DIY builds most often go wrongOften ships a mobile app, sometimes with per-guard licence fees on topNone — patrol evidence lives in WhatsApp messages and paper occurrence books
Permissions and client data separationRole profiles plus server-side `get_permission_query_conditions`; supervisors see only their sites, never ratesFrequently UI-only hiding, which leaks the moment someone opens a report or the APIGeneric role setup; per-site restriction and rate-field masking usually need customisationStandard Frappe permissions exist, but there are no site or post records to scope them to
Cost shape and riskFixed scope, fixed price, UAT on staging with a rollback plan before the production installOpen-ended day rate with the domain-learning curve billed to youLow licence cost; the real cost appears later as workarounds and manual reconciliationNo software cost; the cost is the margin lost between rostered, covered and invoiced hours

Frequently Asked Questions about Security Guard Services Management

How long does delivery take, and can I download it today?

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 one working week 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.

Which Frappe and ERPNext versions do you support, and what happens when I upgrade?

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.

What support do I get after go-live, and how do updates work?

Every build includes a post-go-live support window — two weeks — 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.

Do you replace ERPNext HR and payroll with your own?

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.

Can guards and supervisors use this in the field without buying devices?

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.

Can supervisors be stopped from seeing other clients' sites and our rate cards?

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.

We have unusual shift patterns and a national licensing regime — will it fit?

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.

ऑर्डर पर निर्मित
School & Academic Management
ERPNext

School & Academic Management

A full school operating system on ERPNext covering admissions, attendance, timetables, examinations, and fee collection. ECOSIRE builds it to your institution's scope, installs it on your Frappe site, and supports it after go-live.

From $999.00प्रारंभिक मूल्य — आपके कार्यक्षेत्र के अनुसार तय किया जाएगा
ऑर्डर पर निर्मित
Scrap & Recycling Management
ERPNext

Scrap & Recycling Management

A build-to-order ERPNext application for scrap yards and recycling plants that captures weighbridge-based scrap purchases, grades and segregates material, tracks processing yield, and settles vendors and dealers. ECOSIRE scopes, builds, installs, and supports it — it is not an off-the-shelf download.

From $999.00प्रारंभिक मूल्य — आपके कार्यक्षेत्र के अनुसार तय किया जाएगा
ऑर्डर पर निर्मित
Solar EPC Project Management for ERPNext
ERPNext

Solar EPC Project Management for ERPNext

A build-to-order ERPNext application that runs a solar EPC business end to end — from site survey and system design through project BOM, procurement, installation scheduling, subsidy and net-metering paperwork, and post-commissioning O&M. ECOSIRE scopes, builds, installs and supports it on your bench.

From $999.00प्रारंभिक मूल्य — आपके कार्यक्षेत्र के अनुसार तय किया जाएगा
कोटेशन का अनुरोध करें

Security Guard Services Management

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.

  • `Guard Site` and `Guard Post` DocTypes linked to the ERPNext `Customer`, with a child table of coverage requirements: days, start/end time, headcount, armed/unarmed, and required licence class per post
  • `Guard Roster` generation that expands every post-day in a period into individual `Roster Shift` records, including overnight shifts that cross midnight and configurable rotation patterns (4-on/4-off, 2-2-3, nights-only)
  • `validate` hooks on `Roster Shift` that block double-booking, missing or expired credentials for the post's required class, and breaches of configured weekly-hours or consecutive-night limits — each as a distinct `frappe.throw` message
  • `Guard Credential` child table on `Employee` holding licence number, class, issuing authority and `expiry_date`, with a daily `scheduler_events` job raising 30/14/7-day expiry warnings and flagging shifts that would use a lapsed licence

कोटेशन का अनुरोध करें

हमें Security Guard Services Management के लिए अपनी ज़रूरतें बताएं और हम आपको कीमत, लाइसेंस विकल्प और एक अनुकूलित प्रस्ताव भेजेंगे — आमतौर पर एक कार्यदिवस के भीतर।

अभी कोई भुगतान नहीं। यह हमारी टीम को एक कोटेशन अनुरोध भेजता है — हम कीमत और अगले चरणों के साथ ईमेल द्वारा संपर्क करेंगे।