They redline in Word.
You keep one source of truth
Convorge runs the whole contract journey: intake, authoring, negotiation, approval, signature, repository and renewals. The counterparty just receives an email with a Word file, exactly as they do today, and never has to adopt your software.
Contract tools don't fail at drafting.
They fail the moment the other side says no
Outside counsel won't log in
Every contract platform asks the counterparty to create an account and negotiate in a portal. That is precisely the step the other side's lawyer refuses, and one refusal is enough to route the whole contract back to email.
So the contract forks
The real version becomes an attachment in someone's inbox. Two people are editing two copies, and the system you bought is now a filing cabinet with a login.
And the gate gets walked around
When approvals live in the interface rather than the engine, there is always a way to send anyway, and an audit trail that records the approval you skipped is worth nothing.
Word and email are transport.
Convorge is the record
Send a contract out and Convorge exports real Microsoft Word tracked changes: proper OOXML revisions, verified against genuine Word output, including multi-paragraph edits and table rows. The counterparty redlines it however they like and replies. Convorge imports their marked-up file and turns each edit back into a reviewable change request you can accept or reject.
Never a parallel copy
The document that travels is transport; the version in Convorge stays the record. Accepting a change request writes a new immutable version, so the two can never drift into two different truths.
Nothing silently dropped
If anything in a round trip cannot be represented faithfully, Convorge reports it rather than quietly discarding it. Silent loss is the failure that destroys trust in every document-exchange tool, and it was designed against from the start.
Intake to renewal, in one system
Every stage below is shipped and running in production, not a roadmap.
- 01
Intake
Template or upload
- 02
Authoring
Clause library, smart fields
- 03
Negotiation
Redlines, tracked
- 04
Approval
Chains, auto-routed
- 05
Execution
Your signature provider
- 06
Repository
Searchable, filterable
- 07
Renewals
Key dates tracked
Rules that live in the engine,
not the interface
A control you can click past is not a control. These four are enforced below the application, which is what makes the record defensible later.
The send gate cannot be walked around
A contract does not go out for signature until its approval chain is complete. There is no “send anyway” and no admin override in the interface, because the rule lives in the decision engine rather than the UI. That is what makes the audit trail worth reading.
Versions are immutable
Accepting a change request produces a new version in one atomic transaction: no partial applies, no lost concurrent edits, and nothing edited in place. The history is the record, not a summary of it.
The audit trail is insert-only
Rows can be written and never changed or deleted. Every state change on a contract is attributable to a person, a version and a moment.
Isolation is enforced by the database
Every tenant table is fenced with PostgreSQL row-level security that the application role cannot bypass. Most SaaS multi-tenancy is a WHERE clause and a promise.
A participant, not a guest
When the other side does want to come in, they get a relationship-scoped portal login: a genuinely separate identity plane, not a seat in your workspace. They can read the exact version shared with them, comment, propose changes, watch status, and where they sit on an approval chain, formally approve or reject.
- Access pinned to the exact version shared, never your whole repository
- Magic-link, invite or password entry, with one-time-code verification at redemption
- Rate-limited, revocable, and cut off the moment the relationship ends
- The portal wears its own colour plane, so nobody confuses it for your workspace
The counterparty plane runs on a second, strictly narrowed database role granted only read and insert. A counterparty cannot modify a contract at the database level regardless of what any application code does, including code we might get wrong.
Built as a workspace, not a document viewer
A repository you can actually work in
Status, counterparty, type, value, effective, expiry and renewal dates, source, tags and your own metadata, with typed filters, active-filter chips and saved views. Switch between a table and a kanban board by lifecycle stage.
Key dates that surface themselves
Expiry, renewal and notice windows tracked per contract, so the renewal you meant to renegotiate does not roll over while nobody was looking.
One stream per contract
Change requests, comment threads, approvals and version history in a single chronological view across both sides, instead of reconstructing what happened from an inbox.
Amanda (AI), where you ask for her
Amanda helps draft and edit inside the editor and pre-fills a proposed redline for you to review. She is non-gating (nothing waits on her), and an organisation that has not enabled AI simply never sees her.
Keep the signing platform you already standardised on
Signing sits behind a provider interface with per-organisation credentials encrypted at rest, so adding a provider is a new adapter rather than a migration. Convorge is not a bolt-on upsell to a signature vendor's contract, which also means switching yours later is not a reason to switch this.
The rest of the house
Bring your worst contract.
We'll round-trip it
Send us a real redlined Word file and we will show you it coming back as reviewable change requests, with the approval chain that has to clear before it can go anywhere.