Quotation & Proposal Builder with E-Signature

Key Features

New Frappe app + module installed via `bench get-app` / `bench install-app`, no core ERPNext files patched

Custom DocTypes: `Proposal`, `Proposal Template`, `Proposal View Log`, `Signature Request` linked to native `Quotation`

Reusable `Proposal Template` DocType with Jinja rendering, your letterhead, terms blocks, and live pricing from the linked Quotation

Tokenized public proposal URL served by a Frappe website route + `@frappe.whitelist(allow_guest=True)` method — no login required for the buyer

Per-view tracking: every open/scroll/download writes a `Proposal View Log` row with timestamp, IP, and user agent

Embedded e-signature pad (draw or type) stored as an image with signer name, email, timestamp, and IP for the audit trail

Accept action triggers a `hooks.py` `doc_events` / server-script handler that creates or submits the downstream `Sales Order` from the Quotation

Decline action captures a reason, notifies the owner, and updates proposal workflow state

View/open/accept/decline notifications via Frappe's email queue plus optional real-time Desk toasts

Scheduler event (`scheduler_events`) sends automated follow-up reminders on viewed-but-unsigned proposals

Client scripts drive the in-Desk compose experience and one-click 'Generate Proposal from Quotation'

DocType permissions + role profiles so managers see team proposals while reps see only their own

Whitelisted REST API methods to send, fetch status, and pull signed documents into external portals or automations

Workflow states (Draft / Sent / Viewed / Signed / Declined / Expired) with configurable expiry and versioning of re-sent proposals

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

Sales teams on ERPNext hit a wall the moment a Quotation needs to leave the system. Native ERPNext lets you build a Quotation, attach a Print Format, and email a PDF — but there is no branded web proposal, no shareable link that works without a login, no way to know if the buyer even opened it, and certainly no legally-meaningful e-signature. Reps end up exporting PDFs, chasing DocuSign or PandaDoc in a separate tab, then manually re-keying an accepted deal back into a Sales Order. That gap is where deals stall and where your ERPNext data drifts out of sync with what was actually signed.

ECOSIRE builds a proper Frappe app — its own module, installed on your bench with bench get-app and bench install-app — that closes that gap end to end without leaving ERPNext. We add DocTypes such as Proposal, Proposal Template, Proposal View Log, and Signature Request that hang off your existing Quotation. A rep composes a branded proposal from a reusable Proposal Template (Jinja-rendered, using your letterhead, terms, and pricing pulled live from the linked Quotation), then publishes it to a tokenized public URL served by a Frappe website route and a @frappe.whitelist(allow_guest=True) method. Every open, scroll, and download writes a row to Proposal View Log, so the rep sees "viewed 3 times, last opened 2 hours ago" instead of guessing.

Signature capture is embedded in that same page: the signer draws or types their signature, which is stored as a Signature Request child record with the captured image, signer name/email, timestamp, and IP address for an audit trail. On submit, a hooks.py doc_events handler (or a dedicated server script) flips the proposal state and — this is the payoff — programmatically creates or submits the downstream Sales Order from the accepted Quotation, so an accepted proposal becomes a real ERPNext document with zero re-keying. Decline routes back to the owner with the reason logged. Notifications for view/open/accept/decline are delivered through Frappe's email queue and optional real-time toasts, and a scheduler event (scheduler_events in hooks.py) sends follow-up nudges on proposals that have been viewed but not signed after N days.

Because it is a native app, everything respects ERPNext's permission model: DocType permissions and role profiles control who can send and who can see whose proposals, client scripts drive the compose UX inside the Desk, and the whole thing is reachable over the standard Frappe REST API and whitelisted methods for any portal or automation you already run. It is built and tested against Frappe/ERPNext v15 and v16.

This is a build-to-order product, not a marketplace download. After a short scoping call we confirm your exact requirements — branding, template structure, which Quotation fields flow into the proposal, your Sales Order automation rules, and any approval steps — then build your version, run UAT on a staging site, install it on production, and hand over the git repository. Typical delivery is 2-4 weeks from confirmed scope, and every deployment includes a post-go-live support window.

What you get

Installable source code for your version of the app — a self-contained Frappe app you own

Installation and configuration on your ERPNext site (or a staging environment you nominate), including bench setup and site config

Technical documentation: DocType schema, hooks, whitelisted methods, and permission model

User guide plus a live training session for your sales team and administrators

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

UAT on a staging site before production cutover, with a documented rollback plan

Full git repository handover so you can self-host, extend, or hand to another developer

Sample `Proposal Template` and Print Format seeded with your branding to build on

Who this is for

Sales Manager on ERPNext

Runs a team that lives in ERPNext Quotations but sends proposals over PDF and email. Needs visibility into which proposals were opened and signed, and wants accepted deals to become Sales Orders automatically instead of being re-keyed.

Account Executive / Sales Rep

Sends proposals daily and wants a branded, professional document out the door in minutes — with an open notification and an in-line signature so the buyer never has to print, scan, or wait on a separate e-sign tool.

ERPNext System Administrator

Owns the bench and the site. Wants a clean native app with proper DocType permissions, no core patches, versioned in git, and compatible with the v15/v16 upgrade path — not a fragile pile of client scripts and custom fields.

Operations / RevOps Lead

Needs the quote-to-order handoff to be auditable: who signed, when, from what IP, and which Sales Order it produced. Wants the signature record and view log queryable via the REST API for reporting.

How Quotation & Proposal Builder with E-Signature Compares

Criterion	ECOSIRE	Custom Build	Competitor
Branded web proposal (not just PDF)	Jinja-rendered `Proposal Template` on a public tokenized URL	Possible but you design and build the template engine	Fixed template, limited to the vendor's layout
Open / view tracking	Per-view rows in `Proposal View Log` with IP and timestamp	Must be built and instrumented from scratch	Basic open tracking, often not stored in ERPNext
E-signature capture	Embedded pad, stored as `Signature Request` with audit trail	Integrate a third-party e-sign API yourself	Usually add-on or external DocuSign/PandaDoc link
Accept → Sales Order automation	`doc_events` handler creates/submits the SO automatically	You write and test the automation and edge cases	Rarely writes back into ERPNext natively
ERPNext data integrity	Native DocTypes, permissions, and REST API — one system	Depends entirely on your build quality	Signed doc often lives in the vendor's cloud, not ERPNext
Fit to your process	Scoped to your fields, branding, and approval rules	Fully bespoke, at full DIY cost and timeline	Configure within the vendor's fixed feature set
Ownership & maintainability	Full git repo handover, you own the source	You own it but also carry all the build risk	Licensed — no source, subject to vendor roadmap
Support & v15/v16 compatibility	Post-go-live window + optional retainer, tested on v15/v16	Your team maintains it indefinitely	Vendor SLA, tied to their release cadence

Frequently Asked Questions about Quotation & Proposal Builder with E-Signature

How long does delivery take?

This is a build-to-order product. After a scoping call to confirm your requirements, typical delivery is 2-4 weeks from confirmed scope. That covers building your version, testing on a staging site, UAT, and production install. Tighter or larger scopes shift that window, and we confirm the estimate in writing before you commit.

Is this a Frappe Cloud Marketplace app I can just download?

No. ECOSIRE builds, installs, and supports it for you as a native Frappe app tailored to your ERPNext site and branding. You receive the full git repository and own the source — there is no instant download because each build is scoped to your Quotation fields, Sales Order rules, and approval flow.

Which ERPNext versions do you support?

We build and test against Frappe/ERPNext v15 and v16. During scoping we confirm your exact version and bench setup so the app installs cleanly and follows the upgrade path for your major version.

How do accepted proposals become Sales Orders?

When a buyer signs, a `hooks.py` `doc_events` handler (or dedicated server script) fires and programmatically creates or submits the downstream `Sales Order` from the linked `Quotation` — no manual re-keying. The exact automation rules (draft vs. submitted, approval gates, which fields map) are agreed during scoping.

Are the e-signatures legally usable and auditable?

Each signature is stored as a `Signature Request` record with the signature image, signer name and email, timestamp, and captured IP address, producing an audit trail suitable for standard electronic-signature (e.g. eIDAS simple / ESIGN-style) use. We are not a certified qualified-signature authority; if you need QES or a specific regulatory standard, tell us during scoping and we will advise.

What support and updates come with it?

Every deployment includes a post-go-live support window for bug fixes and configuration adjustments. Because you receive the git repository, you can maintain it in-house afterward, or contract ECOSIRE for a support/retainer arrangement covering v15/v16 compatibility, enhancements, and new features.

Will it interfere with our ERPNext core or upgrades?

No. It ships as a separate Frappe app with its own module and DocTypes — installed via `bench install-app`, not by patching core files. It respects the standard permission model and REST API, so it survives ERPNext upgrades within its supported major version the same way any well-behaved custom app does.