A quote is approved within the CRM system. The client agrees, the price is set, and yet, a peculiar ritual often begins: someone downloads a Word file, fills in the details, and emails a PDF.
The recipient prints it out, signs it, and sends back a scan. Or worse, they return a modified version, with no clear indication of what exactly has been changed. Meanwhile, the software remains completely unaware of these developments.
The problem isn’t the PDF itself
Sending a PDF is not, in itself, a bad practice. The format is widely supported and well-suited for sharing documents with a fixed layout. The issues arise primarily around the file. Who has the latest version? Is the recipient authorized to sign? And how does the finance or administration department know that the agreement has been finalized?
An e-signature platform can handle part of this workload. Through a feature like ‘request a signature,’ the client receives a request to sign the contract digitally, allowing the sender to track its status. However, simply replacing an email attachment with a link does not constitute a fully automated process.
A CRM system is not a document archive
Consider a supplier that enters into dozens of maintenance contracts every month. The terms are stored in the CRM, invoicing is handled via accounting software, and the documents end up in a shared folder. If the contract duration changes, someone must verify that all three systems still contain the same information, a process that is prone to error.
Effective document generation, therefore, begins with the source data. For instance, a template can automatically pull the client’s name, the contract duration, and the agreed-upon price directly from the CRM. The application generates a document from this data and records the specific information used to create it. This is important: if a price is adjusted later, the signed contract should not automatically change as a result.
Webhooks are useful, but not infallible
Integration with an e-signature platform typically takes place via an API. The business software sends the document and receives an identification number in return, which can then be used to check the document’s status. Many services also offer webhooks notifications sent to a pre-configured address whenever someone opens, declines, or signs a document.
Such a notification does not guarantee that the receiving application will process it exactly once. In the event of a time-out, a platform might resend the same event. Developers must therefore verify whether an event has already been processed, for instance by checking a unique event ID. Furthermore, the recipient must verify that the webhook actually originated from the platform; otherwise, a forged request could incorrectly mark a contract as ‘signed.’
An image of a signature proves little
A scribble made with a mouse may look familiar, but on its own, it says very little about the signer’s identity. The same applies to a scanned signature at the bottom of a PDF. Its legal and technical value depends on the entire signing process, including how the signer is identified and how the integrity of the document is maintained.
The archive is part of the workflow
The process does not end with the signature. The final version must be stored in the appropriate location, ideally accompanied by relevant data regarding the signing process. A filename like “contract_new_final3.pdf” is of little help here. A unique contract number, along with metadata concerning the client, date, and duration, makes documents far easier to retrieve. It must also be clear who has access to these documents; for instance, a signed employment contract should not be accessible to every employee who happens to have access to the shared storage system.
The retention period also warrants attention. Not every document may, or should be, stored for the same length of time. An automated archive lacking a deletion policy will eventually become a collection of outdated personal data and agreements that no one ever looks at again. Backups further complicate this, as a deleted document may persist within them for some time. Consequently, the most challenging aspect of document automation is not the act of signing itself, but rather determining how the data is handled both before and after that moment.

