Perhaps the world’s most successful piece of legal tech: Microsoft Word. Market penetration? Somewhere around 99.9%. Its status as the world’s reserve currency for documents means that despite its limitations, Word ‘hosts’ the majority of contracts that exist in the world.
But Word was never built for the particular needs of contracts, nor for the collaborative, dynamic digital environment we work in today, with platforms like Notion and Airtable squeezing out older formats.
Below we look at how Word handles each stage of the contract lifecycle, and compare it to how Juro handles the same stage, so you can see the strengths and limitations of each system when it comes to automating routine contracts at scale. If the future growth of your business will involve increasing volumes of contracts, it’s useful to consider whether a manual, Word-based process will scale with your company’s ambitions.
If you want to find out more about all-in-one contract automation that scales with your business, get in touch - hit the button below.
Microsoft Word has probably the world’s best text editor - at least, by measure of how many people are able to use it. It’s so ingrained that every other editor that wilfully departs from its principles - notably Pages by Apple - feels weird and unintuitive. If the most important thing to you when creating a contract, offer letter or any other document with legal implications is your level of comfort with the editor, then Word is the clear choice.
The problem is that most contracts in Word - particularly for businesses generating them at scale - aren’t created by using the editor to write clauses. They’re created by copying and pasting from old Word documents, or from templates users have to hand. This leads to issues with contract language that can have serious implications.
As contract language guru Ken Adams puts it, “The ubiquity of copy and paste for generations has meant there’s a disconnect between what people think is in contracts, and what’s actually in them. I see a lot of cluelessness out there as a byproduct of the copy/paste machine.”
Another recurring theme of contract creation in Word is version control. Every lawyer out there who has some variation on ‘MSA_2020_Final_finalfinal.doc’ on their desktop knows what we’re talking about. This problem persists because Word documents are static files, rather than dynamic in-browser documents updating in real time, built from structured data. It’s a problem that recurs at each stage of the lifecycle.
Document creation from templates, in the case of commonly required contracts, is also heavily manual. While it might be possible to push values from a spreadsheet into defined fields in a table, for example, this isn’t a common use-case and is too complex for most users.
Finally, while great for words, the Word editor is limited in its functionality beyond simple text. If you’d like to embed multimedia, for example, or responsive images, the editor’s page-based structure will struggle to cope.
Most widely adopted editor anywhere
Rich in editing features
Encourages unthinking copy/paste
Leads to version control issues
Poor handling of rich media
Ill-suited to populating template fields at scale
Creating contracts in Juro
Juro’s editor, like pretty much every editor in any software package on Earth, doesn’t have the depth of word processing features that Microsoft Word can offer. It does have a deep bench of formatting, font and layout options though:
However, instead of being an editor for basic documents that’s used for contracts, Juro offers an editor built on a JSON layer that was purpose-built for contracts. Its editing functionality enables things like:
Tagging certain areas of the contract as ‘smartfields’ (metadata containers)
Commenting, to highlight areas that merit discussion, need approval or negotiation in the sidebar
Creating conditional logic to build fallback positions and variations into the contract
Contract locking, so that certain users can’t change certain parts of the text
A timeline, so users can scroll back through previous versions with one click
The second key difference is in how contracts are created, once templates have been built in the editor. Instead of a copy/paste process, users go through a Q&A flow to populate the smartfields in the contracts.
This means that users can easily enter the most important values, without the risk that they change something that should remain standard in every contract derived from that template. This is a key feature to enable non-legal users to work with contract language safely - without the risk of Ken Adams’ copy/paste machine.
Finally, Juro is an entirely cloud-based solution, with documents built from structured data and accessible in-browser. This means version control isn’t an issue because parallel versions don’t need to be created and saved locally.
Purpose-built contract editor
Rich set of features for creating and editing legal documents
Q&A flow to create documents quickly from templates
Smaller feature set for formatting text
Collaborating on contracts in Word
When it’s time to send a legal document to a colleague for approval in Word, the typical workflow is to download the document to a static file, give the file a name, like MSA_v3.docx, and email it to your colleague. Nowadays this document sharing might alternatively happen in Slack or, of course, Microsoft Teams.
Then they send a file back. It may or may not be the same file. Perhaps you follow up with a call just to check. Certainly more emails are exchanged. Eventually you confirm somehow that the approver is happy, and your contract is ready to share externally.
Static files are simple to share
All colleagues know how to edit a Word document
Approval process likely to create parallel versions
Approval is a manual process that happens outside the software
Collaborating on contracts in Juro
More traditional businesses might not be ready to move to a browser-based collaborative platform, and prefer to send files. But increasingly, businesses of all types are ready for browser-native business solutions. If a contract created in Juro needs input from a colleague, then the simplest way to get input is to mention them:
When it’s time to get your contract approved, you just hit a button to send it for approval. The approver receives a unique email sending them to the contract. When they approve, you’re notified too. No email chain, no phone calls needed, and no version control issues:
Collaboration and approvals all happens in-browser
No version control issues; full audit trail
New way of working for some more traditional businesses
Negotiating contracts in Word
Negotiating contracts in Word has some advantages. In some respects, this is the only element of Word where the document’s status as a static file isn’t always a disadvantage: one side makes its changes in isolation, and can work on them until they’re happy. Only when they’re ready do they need to share them with the other side, who can get to work in tracked changes (more on those later).
This workflow is one reason why Microsoft Word is often preferred to Google docs when it comes to contracts. Simply, parties (especially lawyers) don’t like the idea that the other party can see them making changes in real time. It’s a bit uncomfortable trying to improve clause language to favour your position, knowing that your opposite number is clocking your typos as they happen.
The redlining experience itself, however, is pretty painful. Firstly there’s the simple fact that tracked changes look really messy and can be hard to manage - they’re local. Secondly, people often forget to actually *turn on* tracked changes. Thirdly, tracked changes only work if they remain securely tied to a specific version - and as we know, versions in Word can get out of control easily. This leads to parties chasing versions around email chains and via phone calls, which can be a huge waste of time.
This also means changes can be missed or rolled back, and the audit trail of who did what when is hard to follow. And if, at the end of the process, the contract becomes a PDF, what happens to all that negotiation data? It’s gone. Forever.
You can make changes without the other side seeing them in real time
Tracked changes functionality is (in theory) widely understood
Tracked changes only work if version control works - and it doesn’t
The audit trail of negotiation data is lost if the document becomes a PDF
A tracked changes workflow still needs phone calls and emails to work
Negotiating contracts in Juro
A key differentiator for Juro is that it offers the ability to separate your internal and external comments. If you discussed commercial values at length internally until you arrived at a final figure, don’t worry - the counterparty will never see those comments. For you, it’s a simple click to toggle between them:
Negotiation also happens entirely in-browser. This means there’s no broken email chain to keep track of, no old versions to dig out and compare, and no confusion as to what the current position is. One document, one sidebar, one outcome. Spend your time worrying about the contract, not the contract process.
Of course, the more heavily negotiated the contract is, the less suitable it is for automation at scale. Pretty much by definition, contracts that aren’t standardized and largely commoditized will require more manual work to get them over the line - regardless of how they’re managed. This means that certain contracts, with seriously high values and unavoidably complex negotiations, will probably always be negotiated offline.
In-browser negotiation gives a complete audit trail with no version control issues
Parties can hide internal comments from each other, and control which edits and comments their counterparties see
Automation platforms are less suited to highly negotiated documents that tend to always require ‘in person’ (or close to it) negotiation
Agreeing (eSigning) contracts in Word
There exists the ability to insert a signature in Word, but it’s fairly basic. With the cursor where you want your signature to appear, from the ‘Insert’ tab, choose ‘Text, then ‘Signature List’, then finally ‘Microsoft Office Signature Line’. You can set up the signature at this point, by entering the signing party’s name.
If you’re receiving this document and want to sign it, you can just right-click the signature line and click ‘Sign’, to insert your signature. There is a level of certification behind the digital signature you see in Microsoft Word.
However, this user experience is significantly more clunky than the eSignature solutions we’re all familiar with, like DocuSign, or Juro’s native eSignature, as we’ll see. It’s difficult to use on mobile or tablet. You’ll also need to manually send the signed document to its next recipient, rather than all parties being automatically emailed a copy upon full signature.
It’s also essentially manual, meaning it has to be done one at a time. If you’re a CEO, and still your company’s authorized signatory, you might need to sign dozens or hundreds of sales contracts a month. It’s an incredibly expensive use of your time to be clicking into each document one by one to sign it, or worse, making do with a wet signature.
eSignature (to some degree) is just a right-click away
Word’s editor is fairly flexible as to where you sign documents
No mobile-responsive secure eSigning on any device
No automated mailing of fully signed contracts to all parties
Heavily manual process, especially for high volumes
Agreeing (eSigning) contracts in Juro
Getting a contract ready for signing in Juro is as simple as dropping a signing block on the contract and hitting the green button to share it. This encourages a quick signing flow - counterparties are emailed the signing request, and then they can securely eSign, either by drawing or typing their signature, on any device.
When the contract is fully signed, a PDF copy is emailed to all parties for their records automatically. No more hunting around for a signed and scanned hard copy - and because Juro contracts are built on structured data, they’re searchable within your in-browser contracts database.
Building eSignature within an automation platform also meant that Juro could enable what are called ‘mass actions’. If an authorized signatory has a stack of 100 new partner agreements to sign, she can just select them all from a table view, and hit sign - with one click.
Intuitive, flexible signing flow
Mobile-responsive, secure eSignature on any device
Parties are automatically sent a copy of the fully signed contract
Signatories can sign dozens of contracts at a time with one click
eSignature is native, so you’ll eventually phase out any other eSignature providers you used to use
Managing contracts in Word
This part of the lifecycle really shows the limitations of Word as a contracts platform. The management of contracts post-signature really means two things: renewal reminders, and analytics.
Unfortunately Word offers neither of these, as it’s a word processor. You’ll need to upload your contracts to a separate contract review system which - at some considerable cost - will try to use AI to tell you about the renewals you’ve committed to.
It will also attempt to show you analytics data on your contract workflow, but as it’s already moved to a different system, this data will be incomplete and in any case, you’ve added a new phase to your contracts process just by doing it.
You have no visibility of renewals (or other date-contingent obligations)
You can’t search within your contracts
You have no native analytics on the contract workflow
Managing contracts in Juro
To set up a renewal reminder in Juro, you simply select the smartfield containing the date, and choose the time period in advance of which you’d like to be reminded. You can add additional members if the reminder is relevant to several people.
On the analytics side, users can create a custom dashboard with their own table view, data visualizations, and helicopter view of the contract workflow, end-to-end:
But if you want to know what’s in your contracts, there’s no need to worry about AI contract review, data extraction, and so forth. Your contracts are made from structured data - just search for whatever it is you’re looking for and you’ll find it with a success rate of 100 per cent.
Searchable contracts mean no need for contract review software
Customize reminders to make sure you never miss a renewal again
Use analytics to spot bottlenecks and pain points in your contract workflow
If you prefer to work with static files, your data extraction will be harder from a collaborative, browser-based platform
Which is best?
From a pure document editing point of view, it’s no surprise that Microsoft Word is streets ahead not just of contract automation platforms, but indeed of pretty much anything else on Earth that purports to edit documents. That’s what you get from a Word processor that’s been refined and improved constantly since the 80s - category-defining features.
But if the document in question is intended to be a binding contract, and you need to automate and manage it at scale to drive business growth, then the analysis above shows that Word is manifestly unsuitable and lacking in the killer features you need to make contracts move quickly, enabling rather than blocking growth.
If you’d like to road-test Juro’s features and road-test them in comparison to Word, hit the button below and find out more. And if you can’t quite achieve the result you were looking for, remember - you can always export to a Word document anyway.