Send the contract for signature from the deal.
The agreement is already on the record. It goes out from there, comes back signed to the same place, and the deal knows it happened.
One less tab, and one less copy of the contract.
No re-uploading the PDF somewhere else, no wondering which version got signed, and no second copy of the same agreement landing in a client's inbox.
How it goes out
The contract attached to the deal is the one that gets sent. You place the signature fields on it, pick who signs, and it goes. The signed copy returns to the same deal record rather than to whoever happened to start the request.
What is in it
It tells you why it is not ready. No contract file. The file needs converting to PDF. No email on the client. Each one comes back as a plain sentence and a next step, not a failed send you find out about later.
One open request per deal, enforced. Not a convention — the system will not let a second signature request exist on a deal that already has one out. A client cannot receive two versions of the same contract from two people on your team.
You see where it actually is. Sent, viewed, partially signed, signed, declined, expired, canceled. Viewed matters: it is the difference between a client who has not seen it and one who has and is thinking about it.
Fields placed where they belong. Signature and date fields go where you put them on the document, rather than at whatever spot a generic tool guesses.
Self-hosted signing. The signing runs on infrastructure we operate rather than a third-party signing service. Your clients' contracts do not become another company's data.
An audit trail that survives the plumbing. Every request records which signing backend handled it, so changing the underlying service later does not orphan the history of anything already sent.
Why signing inside the deal is different from signing next to it
The version question disappears. When signing happens somewhere else, the signed PDF and the deal record drift apart — and six months on, nobody is certain the file in the folder is the one that got countersigned.
The status is on the thing you are managing. Chasing a signature means checking the deal, not a separate dashboard whose notifications somebody muted.
What the contract says survives the signing. The terms were already extracted into fields before it went out. Signing does not turn the agreement back into an opaque document.
Music contracts are long and the signable part is small. A twelve-page publishing agreement has one signature block. Placing fields on the real document beats re-creating the agreement inside a signing tool's editor.
What it does not do yet
Today it sends to your client. The signer is the person whose deal it is. Counterparty, co-writer and witness signing are modeled but not built, so a genuine two-party countersign still happens the way it happens now.
Saying so matters more than it costs: a signing feature you discover the limits of halfway through a deal is worse than one you knew the shape of on day one.
Common questions
Do I need a separate e-signature subscription?
No. Signing is part of the workspace and runs on infrastructure we operate, so there is no third-party signing account to buy, connect or administer.
Where does the signed contract end up?
On the deal it came from, alongside every earlier version of the file. Not in a separate system you have to remember to check and copy from.
What if the contract is a Word file?
It tells you it needs converting to PDF before sending, rather than failing silently. That is one of several readiness checks that run before anything reaches a client.
Can two people accidentally send the same contract twice?
No. A deal can only have one signature request open at a time, and that is enforced by the system rather than by everyone remembering. It is the failure that embarrasses you in front of a client, so it is the one worth making impossible.
Can the counterparty sign too?
Not yet. Today the request goes to your client. Counterparty, co-writer and witness roles exist in the model and are additive, but two-party countersigning is not built.
Place the fields. Send it. Watch it come back signed.
