A build-to-order ERPNext app that fires targeted web push and Firebase Cloud Messaging (FCM) mobile push from `hooks.py` doc events, scheduler jobs, and audience-segmented campaigns. ECOSIRE scopes, builds, installs, and supports it on your Frappe v15/v16 bench. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $149.00 USD; request a quote for a scoped proposal.

A build-to-order ERPNext app that fires targeted web push and Firebase Cloud Messaging (FCM) mobile push from `hooks.py` doc events, scheduler jobs, and audience-segmented campaigns. ECOSIRE scopes, builds, installs, and supports it on your Frappe v15/v16 bench.
No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.
Your ERPNext portal or companion mobile app has users who need to know the moment something changes: a Sales Order is confirmed, a Support Ticket is reassigned, a payment posts, or a stock item is back in inventory. ERPNext core covers this internally with the Notification DocType and email or in-desk toasts, but that reach stops at logged-in desk users on an open browser tab. There is no native path to a browser-level Web Push notification that lands when the tab is closed, and nothing at all for delivering to a native Android or iOS app via Firebase Cloud Messaging (FCM). Operators who run customer portals or field-service apps on ERPNext end up bolting on a third-party service, which fragments the audience, duplicates the customer list, and cuts the notification off from the exact business events already flowing through the ERP.
Firebase Cloud Messaging (FCM) HTTP v1 integration via the Firebase Admin SDK, with OAuth2 service-account credentials stored in a Frappe Single/Settings DocType (not in code)
Web Push (VAPID) delivery through a registered Service Worker, capturing the W3C PushSubscription endpoint plus `p256dh` and `auth` keys per browser
`Push Subscription` and FCM-token DocTypes keyed to the ERPNext User/Contact, with device metadata, platform, and an active flag
Automatic token hygiene: FCM `NotRegistered`/`Unregistered` and stale Web Push 410 endpoints are pruned so audiences stay deliverable
Event-triggered pushes wired to `doc_events` in `hooks.py` (e.g. `on_submit` of Sales Order, `on_update` of Issue) with per-event template mapping
Scheduler-driven pushes via `scheduler_events` for reminders, renewals, and time-window campaigns
ECOSIRE builds a proper Frappe app — its own module, DocTypes, and hooks.py wiring — that closes that gap end to end. On the browser side we register a Service Worker and capture the W3C Push subscription (endpoint plus p256dh/auth keys) against the signed-in user, storing each in a Push Subscription DocType with device metadata and an active flag. On the mobile side we integrate the Firebase Admin SDK server-side, store FCM registration tokens per device, and handle token refresh and invalidation (pruning NotRegistered/Unregistered tokens returned by Firebase so your audience stays clean). A Push Campaign DocType and a Push Template DocType give your marketing and operations teams a place to compose rich pushes — title, body, image, click-through deep link, and CTA buttons — and target them.
Delivery is driven two ways. Event-triggered pushes hang off doc_events in hooks.py (for example on_submit of Sales Order, on_update of Issue) and off scheduler_events for time-based sends like abandoned-cart or renewal reminders; the heavy lifting runs through the Frappe background queue (frappe.enqueue) so a large fan-out never blocks the web worker. Campaign pushes resolve their audience from saved segments — a Push Segment DocType backed by a report query or filter on Contact, Customer, Portal User, or any linked DocType — so a campaign can target "customers in UAE with an open subscription" without hand-built lists. Whitelisted API methods (@frappe.whitelist()) expose subscription register/unregister and a send endpoint over the Frappe REST API for your front-end and mobile clients, all gated by role-profile permissions so only authorized roles can broadcast. Every send is logged in a Push Log DocType with per-recipient status, provider response, and click-through tracking for open-rate reporting.
Because this is build-to-order, nothing ships as a one-click marketplace download. We start with a short scoping call to confirm which ERPNext events matter to you, your Firebase project details, the DocTypes to segment on, and your v15 or v16 target. We then build your version of the app against a staging bench, run UAT with you, and install it on production with a rollback plan. Typical delivery is 2 to 4 weeks from confirmed scope, and you receive the full source in a git repository you own, so you are never locked to us.
Runs a customer or partner portal on ERPNext and needs order, ticket, and payment updates to reach users even when the tab is closed, without exporting the customer list to a third-party push service.
Has a native Android/iOS companion app backed by ERPNext and needs reliable FCM delivery tied directly to business events and back-office data, with token management handled server-side.
Wants to run segmented push campaigns — renewals, re-engagement, promotions — targeting audiences defined on ERPNext Contacts and Customers, with open-rate and click-through reporting.
Owns the Frappe bench and needs a clean, standards-based app with proper DocTypes, permissioned whitelisted APIs, background-queue fan-out, and a git repo they control on v15/v16.
Buy the license on ecosire.com and download the Push Notifications (Web & Mobile/FCM) for ERPNext app ZIP from your account dashboard.
Extract the ZIP into your bench's apps folder, or run `bench get-app` with the path to the extracted app.
Run `bench --site SITE_NAME install-app APP_NAME` followed by `bench migrate` to install Push Notifications (Web & Mobile/FCM) for ERPNext and apply its schema.
Open the ECOSIRE License settings on your site and activate your license key. Requires the free ecosire_connect and ecosire_license_client apps.
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Delivery model | Build-to-order; scoped, built, and installed for your bench in 2-4 weeks | In-house build; timeline depends on your team's Frappe depth | Instant download but generic; may not fit your events | |
| FCM mobile push | Firebase Admin SDK integration with token lifecycle handling | Possible, but you build and maintain the token plumbing | Sometimes included; token hygiene often shallow | |
| Web push (closed tab) | VAPID + Service Worker capturing full PushSubscription | Doable but easy to get the SW/keys wrong | Varies; often desk-only or third-party redirect | |
| Event triggering | Wired to your `doc_events` and `scheduler_events` in `hooks.py` | You author and test every hook yourself | Usually a fixed, non-configurable event set | |
| Segmentation | `Push Segment` DocType on Contact/Customer/portal queries | Build your own audience resolver | Basic lists; rarely ties to ERPNext filters | |
| Ownership | Full git repo handover; no lock-in | You own it outright | Vendor-controlled; per-seat or SaaS fees common | |
| Reporting | `Push Log` with delivery status, CTR, and open tracking | You design and build the logging | Dashboard exists but may live off-platform | |
| Support | Post-go-live window + optional upgrade retainer | Self-supported by your team | Tiered/paid support, best-effort on custom events |
This is a build-to-order app, not an instant download. After a short scoping call to confirm your events, Firebase project, segments, and target version, typical delivery is 2 to 4 weeks from confirmed scope. We build against a staging bench, run UAT with you, then install on production with a rollback plan.
You provide (or we help you create) a Firebase project and a service-account JSON for the FCM HTTP v1 API, plus your mobile app's Firebase config. We generate the Web Push VAPID key pair, wire the Service Worker, and store all credentials in a Frappe Settings DocType rather than in source code.
Yes. We build and test against your target — Frappe/ERPNext v15 or v16 — as a standard bench-installable app. If you run both (e.g. staging on one, production on another), tell us at scoping and we account for it.
Two ways. Event-triggered pushes hang off `doc_events` in `hooks.py` (for example `on_submit` of a Sales Order) and off `scheduler_events` for time-based sends. Campaign pushes are composed in a `Push Campaign` DocType and sent to a saved `Push Segment`. Fan-out runs through `frappe.enqueue` background workers.
Every engagement includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full git repository, your own team can also maintain and extend the app. We offer ongoing support and version-upgrade retainers separately if you want us to keep it current across Frappe releases.
Yes. Broadcast and campaign actions are gated by role profiles and DocType permissions, so only authorized roles can send. On the recipient side, per-user opt-in/opt-out is honored on every send, and unsubscribed or expired subscriptions are pruned automatically.
You own it. We hand over the complete source in a git repository, along with technical docs and a user guide. There is no license phone-home and no dependency on ECOSIRE to keep it running.
A build-to-order ERPNext app that fires targeted web push and Firebase Cloud Messaging (FCM) mobile push from `hooks.py` doc events, scheduler jobs, and audience-segmented campaigns. ECOSIRE scopes, builds, installs, and supports it on your Frappe v15/v16 bench.