Slack-style team chat built directly into ERPNext, with channels, direct messages, and threads pinned to the exact Sales Order, Task, or HD Ticket being discussed. ECOSIRE builds, installs, and supports it on your Frappe/ERPNext v15/v16 site after you request a quotation. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $99.00 USD; request a quote for a scoped proposal.

Slack-style team chat built directly into ERPNext, with channels, direct messages, and threads pinned to the exact Sales Order, Task, or HD Ticket being discussed. ECOSIRE builds, installs, and supports it on your Frappe/ERPNext v15/v16 site after you request a quotation.
Aucun paiement maintenant. Ceci envoie une demande de devis à notre équipe — nous vous recontacterons par e-mail avec les tarifs et les prochaines étapes.
Cross-functional teams running ERPNext end up living in two worlds: the record is in ERPNext, but the conversation about it happens in Slack, WhatsApp, or email. Decisions get made where the ERP can't see them, context is lost when someone leaves the channel, and a new joiner has no way to reconstruct why a Sales Order was discounted or a HD Ticket was escalated. ERPNext core ships a Comment field and the assignment/notification system, but there is no real-time channel model, no direct messages, no message threads, and no presence — the native tools were built for record annotations, not for a team having a live conversation next to the work.
Dedicated Frappe app exposing `Chat Channel`, `Chat Message`, and `Chat Membership` DocTypes with proper naming series and migrations
Public, private, and direct-message channel types enforced through ERPNext role profiles and DocType permission rules
Message threads bound to any reference document via `reference_doctype` / `reference_name`, rendered in both the chat panel and the source record
Real-time delivery, typing indicators, presence, and unread badges over Frappe's Socket.IO `frappe.realtime` pub/sub — no polling
@mention parsing that fires Frappe `Notification Log` entries plus optional email and mobile push to mentioned users
File sharing on the standard `File` DocType with inline image/PDF previews and permission-aware attachment access
ECOSIRE builds a proper Frappe app — its own module with a Chat Channel, Chat Message, and Chat Membership DocType set — that adds a first-class messaging layer inside ERPNext. Channels and direct messages behave the way your team expects (unread counts, @mentions, threaded replies, reactions, file attachments with inline previews), but every message can also be bound to a reference document via the standard reference_doctype / reference_name link fields. That means a thread can be anchored to a specific Task, Project, Sales Order, or HD Ticket, and the conversation renders both inside the chat panel and in the document's own workspace. Real-time delivery uses Frappe's Socket.IO frappe.realtime pub/sub, so messages, typing indicators, and unread badges push instantly without polling, and everything is governed by ERPNext role profiles and DocType permissions so a channel only shows to users who are entitled to see it.
The integration with your business events is where a build-to-order app pulls ahead of a generic chat plugin. We wire hooks.py doc_events and controlled server scripts so that ERPNext lifecycle changes post structured bot messages into the right channel — a Sales Order submitted, a Purchase Order approved, a ticket breaching SLA, a Stock Entry short on inventory. Scheduled digests are delivered through scheduler_events, and outbound integrations (Slack mirror, email fallback, mobile push) are exposed as @frappe.whitelist() methods over the Frappe REST API so your other systems can post into channels too. Client scripts and a custom Desk page provide the chat UI; permission queries and role checks keep direct messages private; and everything is packaged as versioned, migratable code with proper fixtures so nothing depends on manual site configuration.
Because this is build-to-order, you are not downloading a fixed listing — ECOSIRE scopes the exact channels, event triggers, DocType bindings, and integrations your team needs, then builds and installs them on your Frappe/ERPNext v15 or v16 site. After a short scoping call we confirm the specification, and typical delivery is 2 to 4 weeks from confirmed scope depending on how many event hooks and third-party mirrors you want. We validate on a staging bench first, hand over the git repository and technical documentation, run a training session, and stay on through a post-go-live support window. No fabricated benchmarks, no instant-download promise — real code, built for your instance, that you own.
Coordinators who work Sales Orders, Purchase Orders, and Stock Entries all day and need the conversation about a delivery or shortage to live on the record itself, not in a disconnected chat app.
Managers running ERPNext Helpdesk who want internal threads and escalation chatter pinned to each HD Ticket, with bot alerts firing automatically on SLA breach or reassignment.
Leads driving Projects and Tasks who need @mention-driven accountability, threaded discussion per task, and scheduled digests so nothing stalls silently between updates.
The team responsible for the bench who want a permission-aware, migratable app with clean hooks and API surfaces rather than a brittle plugin that breaks on the next `bench migrate`.
Achetez la licence sur ecosire.com et téléchargez le ZIP de l'application Team Messaging & Collaboration depuis le tableau de bord de votre compte.
Extrayez le ZIP dans le dossier d'applications de votre banc ou exécutez « bench get-app » avec le chemin d'accès à l'application extraite.
Exécutez `bench --site SITE_NAME install-app APP_NAME` suivi de `bench migrate` pour installer Team Messaging & Collaboration et appliquer son schéma.
Ouvrez les paramètres de licence ECOSIRE sur votre site et activez votre clé de licence. Nécessite les applications gratuites ecosire_connect et ecosire_license_client.
| Critère | ÉCOSIRE | Construction personnalisée | Concurrent | Odoo natif |
|---|---|---|---|---|
| Chat inside ERPNext | Native Desk chat with channels, DMs, threads and presence | Possible but you design and build the whole model | Bolt-on chat, often generic and not Desk-integrated | |
| Link to DocTypes | Threads bound to Sales Order, Task, HD Ticket via reference fields | Depends entirely on your build effort | Usually standalone chat, weak record binding | |
| Event-driven bot messages | `hooks.py` doc_events + scheduler post structured alerts | You write and maintain every hook yourself | Rarely wired to your business events | |
| Real-time delivery | Socket.IO `frappe.realtime` pub/sub, no polling | You configure and test realtime plumbing | Varies; some poll or rely on email | |
| Permissions & privacy | Role profiles + permission query conditions per channel | Must be designed and hardened by you | Own permission model, may not respect ERPNext roles | |
| Version support | Built and tested on Frappe/ERPNext v15 and v16 | Whatever you target and maintain | Depends on the vendor's release cadence | |
| Ownership & handover | Full git repo, docs and training handed over | You own it but carry all build cost | Licensed; source often closed | |
| Support model | Post-go-live window plus optional retainer | Your team is the only support | Vendor SLA, generic to all customers |
This is a build-to-order app, not an instant download. After a short scoping call we confirm the specification, and typical delivery is 2 to 4 weeks from confirmed scope. The exact timeline depends on how many event triggers, DocType bindings, and third-party mirrors (Slack, email, push) you want included.
Every build includes a post-go-live support window for defect fixes and configuration tweaks, and we hand over the full git repository so your team owns the code. Beyond the included window we offer ongoing support and version-upgrade retainers, including compatibility work when you move between Frappe/ERPNext major versions.
No. ECOSIRE builds and installs it on your site as a proper Frappe app tailored to your channels, events, and permissions. You receive installable source code and the git repository, and it migrates cleanly across your staging and production benches via `bench migrate`.
We build against Frappe/ERPNext v15 and v16. The app is delivered as versioned, migratable source using standard `hooks.py`, DocTypes, `fixtures`, and whitelisted methods, so it upgrades with your bench rather than fighting it.
Yes — that is the core value. Any thread can be bound to a reference document through `reference_doctype` and `reference_name`, so a conversation attaches to a specific Sales Order, Task, Project, or HD Ticket and renders both in the chat panel and on the source record.
Yes. We wire `hooks.py` `doc_events` (on_submit, on_update, on_cancel) and, where appropriate, controlled server scripts so lifecycle changes — order submitted, PO approved, ticket escalated, stock short — post structured bot messages into the right channel. Scheduled digests use `scheduler_events`.
Channel and message visibility is enforced through ERPNext role profiles, DocType permissions, and permission query conditions. Direct messages and private channels are filtered per user at the query level, so no one sees conversations they are not a member of.
Slack-style team chat built directly into ERPNext, with channels, direct messages, and threads pinned to the exact Sales Order, Task, or HD Ticket being discussed. ECOSIRE builds, installs, and supports it on your Frappe/ERPNext v15/v16 site after you request a quotation.