Contracts in Word vs Contracts in Juro

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.

Creating contracts in Word

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.”

Read Ken’s thoughts in full in The Modern Contract Handbook.

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.

Pros:

• Most widely adopted editor anywhere
• Rich in editing features

Cons:

• 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 a cloud-based contract management system, 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.

Pros:

• Purpose-built contract editor
• Rich set of features for creating and editing legal documents
• Q&A flow to create documents quickly from templates
• Browser-native editing

Cons:

• 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.

Pros:

• Static files are simple to share
• All colleagues know how to edit a Word document

Cons:

• 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:

Pros:

• Collaboration and approvals all happens in-browser
• No version control issues; full audit trail

Cons:

• 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, when you redline in Word, 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.

Pros:

• You can make changes without the other side seeing them in real time
• Tracked changes functionality is (in theory) widely understood

Cons:

• 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.

Pros:

• 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

Cons:

• 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.

Read more about electronic signature in 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.

Pros:

• eSignature (to some degree) is just a right-click away
• Word’s editor is fairly flexible as to where you sign documents

Cons:

• 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.

Pros:

• 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

Cons:

• 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.

Pros:

• We’re struggling

Cons:

• 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.

Pros:

• 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

Cons:

• 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.