Quote-to-Signature Pipeline

The problem

At a marketing agency, every proposal was assembled by hand. A rep priced the deal in a standalone calculator, rebuilt a proposal deck for that specific client, assembled a contract packet page by page depending on which services were sold, then set up signature fields manually in the e-signature platform. The same figures were retyped at each stage, in documents a client would sign.

The cost was not just hours of skilled time per deal. It was elapsed time: a prospect who said yes waited days while presales paperwork caught up, and every handoff was a chance to transcribe a number wrong.

What it does

A rep opens one page and works top to bottom:

1. Configure the quote. Select products with tiers and terms, apply per-item discounts in dollars or percent, add on-the-fly custom line items, toggle promotional offers, and apply referral discounts against the monthly rate, the paid-in-full total, or as a flat credit. The investment breakdown recalculates live underneath.
2. Generate the client proposal. One click produces a branded multi-page PDF from a 22-page template: unselected service pages are removed, the recommended products list is rewritten to match the sale, the cover is populated, and the money pages are rendered from engine output. About two minutes, unattended.
3. Generate the contract packet. A second click produces the signing packet from a separate 20-page template, keeping only the terms pages matching the exact products and tiers sold, and generating payment authorization language (credit card, ACH, or financed) from the quote math.
4. Send for signature. The packet is pushed to the signature platform with fields already placed and routed to the right parties.

Every quote auto-saves with its full state and reloads into the form with one click, so a rep can revive and revise a deal weeks later.

How it works

The browser page and the server share one pricing module. The page uses it to render the live breakdown; the server requires the same file and recomputes the quote before generating any document. The document generator is then given the finished numbers along with an explicit instruction to recompute nothing and reformat nothing. A figure on screen, in the proposal, and on the contract cannot diverge, because only one piece of code is permitted to do arithmetic.

Document assembly is driven server-side rather than left to the generator. The server decides which template pages survive, rewrites the specific overlays that need client data, counts table rows, and packs content into pages against a measured fit budget, emitting explicit continuation pages when a quote is large enough to need them.

Signature integration

• Signing workflow. Documents are created with a sequential signing order: the company president signs first, then the client completes their portion and accepts. On completion the agreement is distributed automatically to the sales rep, accounting, and operations.
• Field placement. The authorization pages are full-page images with no text anchors, so roughly two dozen signature and data fields are positioned by coordinate per packet, routed to the client except the countersignature row, which routes to the owner. Even the page number is computed from the quote itself, since the authorization page shifts depending on how many pages the money tables consumed.
• Two platforms. DocuSign is integrated through JWT service authentication (RS256), creating draft envelopes with the packet loaded and fields routed to both parties. A self-hosted open-source alternative, Documenso, is deployed on the same infrastructure with Postgres, S3-compatible object storage, transactional email, and a signing certificate, and carries the equivalent integration, so the agency is not locked into per-seat signature pricing.

Engineering decisions worth noting

• One source of arithmetic truth. A single shared pricing engine used by browser, server, and document generation, so quote, proposal, and contract figures are provably identical rather than retyped.
• Deterministic layout over generative layout. The AI generator is an unreliable typesetter, so pagination, page selection, and content packing are computed server-side and handed over as instructions. This converted an unpredictable output into a reproducible one.
• Anchoring page removal to image filenames. The template’s service pages are image-only cards with empty text bodies, so removal instructions phrased by page title silently failed and unsold service pages survived into client-facing documents. Anchoring each removal to its background image filename fixed it.
• Measuring instead of estimating. To place signature fields on image-only pages, real generated packets were rendered with a percentage coordinate grid overlaid, positions read off the render, and encoded as a maintainable coordinate map, with the technique documented for future template changes.
• Diagnosing undocumented platform behavior. Several integrations behaved differently from their documentation, each resolved by probing the live service: one self-hosted signature product silently gated document upload behind a paid tier, which killed that option; its replacement required both a current and a legacy environment variable before its API would accept documents at all, and rejected text fields unless an undocumented metadata object was attached. Each finding was verified and written into the maintenance guide.
• Safe by default. Generated documents are always drafts. Nothing is sent to a client automatically, and every credential lives in server-side environment files rather than the repository.

Outcomes

• The presales-to-sales handoff went from days of elapsed back-and-forth to minutes: a deal can be priced, proposed, and queued for signature in the same conversation.
• Proposal production went from manual deck assembly to about two minutes of unattended generation, with the rep reviewing rather than building.
• Contract packets assemble themselves with the correct terms pages for the exact products and tiers sold, removing a manual, error-prone step.
• Quote, proposal, and contract figures are provably identical because they come from one engine.
• Signature routing, signing order, and internal distribution happen automatically instead of being configured by hand per deal.
• 44 quotes generated in production across eight team accounts, with the full pipeline documented and version-controlled for handoff.

The pipeline runs inside the agency’s Team Tools Portal, the authenticated platform that handles accounts, sessions, and the rest of the team’s internal tools.