Fleet Management for ERPNext

Key Features

`Fleet Vehicle` DocType extending ERPNext's native vehicle with child tables for registration, insurance, fitness, and permit documents — each with issue/expiry dates and attachment fields

Configurable expiry alerting via a daily `scheduler_events` job that raises in-app notifications, emails, and ERPNext ToDos at per-document lead times (e.g. 30/15/7 days before expiry)

Driver master with license number, class, and expiry tracking; a `validate` hook blocks assigning a vehicle to a driver whose license has lapsed

`Driver Assignment` DocType with start/end dates and an open-assignment guard so one vehicle can't be double-booked to two active drivers

`Fuel Log` DocType that computes distance from odometer deltas and derives mileage (km/L or L/100km) and cost-per-kilometre on submit

`Trip Log` with start/end odometer capture, per-trip distance and cost roll-up, and validation that readings never move backwards

`Maintenance Schedule` supporting both calendar-interval and mileage-interval rules, with the next occurrence auto-generated on completion of the prior service

`Maintenance Log` capturing parts, labour, vendor, and cost — optionally linked to an ERPNext Purchase Invoice or Stock Entry for spend and inventory reconciliation

Role profiles (Fleet Manager, Driver, Workshop) with DocType- and field-level permissions so drivers see only their own records

Whitelisted REST endpoints (`@frappe.whitelist()`) for telematics/odometer ingestion and mobile fuel capture, all routed through the same server-side validation

Client scripts that auto-populate the last known odometer reading and warn in-form when an entry precedes the previous reading

Frappe Query Reports and Number Cards for fleet running cost, fuel efficiency by vehicle, upcoming expiries, and maintenance-due lists

Naming series and workflow states configured per your operation (e.g. draft → assigned → returned for assignments)

Built and tested against Frappe/ERPNext v15 and v16, packaged as an installable app with proper `hooks.py`, fixtures, and migration-safe custom fields

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

You order

Start with a one-time build price. We scope it with you at kickoff.

We build & install

ECOSIRE builds, configures and installs it on your ERPNext.

Go live + support

You go live in about 2–4 weeks, with a post-launch support window.

About this Product

ERPNext gives you accounting, inventory, and purchasing, but the moment you actually run vehicles it runs out of road. Core ERPNext ships only a thin Vehicle DocType and a Vehicle Log tied to the Expense Claim flow — there is no license-expiry alerting, no preventive maintenance scheduling, no driver-assignment lifecycle, and no fuel-efficiency analytics. Fleet operators end up tracking insurance renewals, fitness certificates, and service intervals in spreadsheets that live outside the system that holds their costs. Missed a registration renewal or an oil-change interval and the fleet is off the road or paying for it later.

ECOSIRE closes that gap with a proper Frappe app (its own module, not a pile of customizations) that installs cleanly onto your bench alongside ERPNext. We model the domain as first-class DocTypes — Fleet Vehicle (extending the native vehicle concept with document sub-tables for registration, insurance, fitness, and permits, each carrying an expiry date), Driver Assignment, Fuel Log, Maintenance Schedule, Maintenance Log, and Trip Log. Business logic lives where Frappe expects it: hooks.py document events (validate, on_submit, on_update) enforce rules like preventing a vehicle from being assigned to a driver whose license has expired, and recalculating mileage and cost-per-kilometre from odometer deltas on every fuel entry. Server scripts and whitelisted methods expose the numbers to ERPNext dashboards; client scripts drive in-form UX such as auto-filling the last odometer reading.

Time-based automation runs on Frappe's scheduler_events — a daily job scans every document sub-table and raises alerts (in-app notification, email, or ERPNext ToDo) at your configured lead times before insurance, registration, or license expiry, and generates the next Maintenance Schedule occurrence from mileage or calendar intervals. Everything is permission-aware: we ship role profiles (for example Fleet Manager and Driver) with DocType-level and field-level permissions so drivers see only their own trips and fuel logs while managers see the whole fleet. All of it is reachable over the standard Frappe REST API and custom whitelisted endpoints, so a telematics feed, a mobile fuel-capture form, or a Power BI report can read and write without bypassing validation.

Because this is build-to-order, nothing is a black box. After a short scoping call we confirm exactly which vehicle document types, alert channels, maintenance rules, and reports your operation needs, then we build against your Frappe/ERPNext v15 or v16 version. We deliver and configure it on your bench, hand over the full git repository and technical docs, run UAT on a staging site with a documented rollback plan before go-live, and stay on for a support window afterward. Typical delivery is 2–4 weeks from confirmed scope.

What you get

Installable source code for your commissioned version, packaged as a standard Frappe app ready for `bench get-app` / `bench install-app`

Installation and configuration on your bench, including role profiles, naming series, scheduler jobs, and alert lead-times

Technical documentation covering DocType schema, `hooks.py` events, whitelisted API endpoints, and scheduler job behavior

End-user guide plus a live training session for fleet managers and workshop/driver roles

UAT on a staging site with a signed-off test plan and a documented rollback procedure before production go-live

Post-go-live support window for defect fixes and configuration adjustments

Full git repository handover so your team owns and can extend the source

Version compatibility confirmation and a migration-safe upgrade note for your Frappe/ERPNext v15 or v16 site

Who this is for

Fleet operations manager on ERPNext

Runs a mixed fleet of owned and hired vehicles and needs one place for assignments, document expiries, and running costs instead of a wall of spreadsheets. Wants expiry alerts to land before renewals lapse, not after.

Logistics SMB owner already on ERPNext

Uses ERPNext for accounts, inventory, and purchasing and refuses to bolt on a separate fleet SaaS with a second login and no cost integration. Wants fuel and maintenance spend to reconcile against Purchase Invoices in the same system.

Workshop / maintenance coordinator

Owns preventive maintenance and needs mileage- and calendar-based service scheduling, parts-and-labour logging, and a clear queue of what's due — with history attached to each vehicle.

ERPNext systems administrator / implementation partner

Responsible for the bench and upgrades; wants a clean, permission-aware Frappe app with proper hooks and fixtures, full source in git, and confirmed v15/v16 compatibility rather than unmanaged one-off customizations.

How Fleet Management for ERPNext Compares

Criterion	ECOSIRE	Custom Build	Competitor
Fleet coverage (documents, drivers, fuel, maintenance)	Complete, built to your scope	Whatever you can spec and build in-house	Fixed feature set, take it or leave it
Expiry & maintenance alerts	Configurable scheduler jobs, multi-channel lead times	Buildable but you own the effort	Basic if present, rarely configurable
ERPNext cost integration (Purchase Invoice / Stock)	Linked to spend and inventory	Possible with dev time	Often siloed from accounts
Source code ownership	Full git repo handed over	You own it	Usually closed/licensed
Fit to your process	Scoped to your naming, roles, rules	Exactly as specified	Adapt your process to the app
Time to running system	2–4 weeks, installed & configured	Months of internal dev	Fast install, then gap-filling
Version compatibility (v15/v16)	Confirmed and migration-safe	Your responsibility to maintain	Depends on maintainer
Support after launch	Post-go-live window + optional ongoing	In-house team only	Vendor tickets, variable SLAs

Frequently Asked Questions about Fleet Management for ERPNext

How long does delivery take?

This is a build-to-order app, not an instant download. Typical delivery is 2–4 weeks from confirmed scope — the range depends on how many vehicle document types, alert channels, maintenance rules, and reports you need. After a short scoping call we agree the exact feature set and timeline in writing before any build starts.

Is this a Frappe Cloud Marketplace app I can install myself?

No. ECOSIRE builds it for your specific requirements and Frappe/ERPNext version, then installs and configures it on your bench. You receive the full git repository and installable source at handover, so your team can maintain and extend it independently afterward.

How does it integrate with ERPNext core rather than sitting beside it?

It's a proper Frappe app with its own module and DocTypes that extend the native vehicle concept. Maintenance and fuel spend can link to ERPNext Purchase Invoices and Stock Entries, everything is exposed over the standard Frappe REST API, and permissions use ERPNext role profiles — so it behaves like part of your ERPNext, not a separate tool.

Which ERPNext versions are supported?

We build and test against Frappe/ERPNext v15 and v16. During scoping we confirm your exact version and branch and build against it, and we provide a migration-safe upgrade note so custom fields and fixtures survive future `bench migrate` runs.

What about support and updates after go-live?

Every engagement includes a post-go-live support window for defect fixes and configuration adjustments. Because you own the source in git, your team can extend it freely; ECOSIRE can also provide ongoing support or version-upgrade work as a separate engagement when you need it.

How do the expiry and maintenance alerts actually work?

A daily Frappe scheduler job scans document expiry dates (insurance, registration, fitness, license) and mileage/calendar maintenance intervals, then raises alerts at your configured lead times through in-app notifications, email, and ERPNext ToDos. The lead times and channels are configurable, not hard-coded.

Will we get the source code, or is it locked?

You get the complete git repository at handover — nothing is obfuscated or locked. The deliverable is installable Frappe app source plus technical docs, so you or any ERPNext partner can maintain, audit, and extend it.