How to Automate Contract Creation with Make [Tutorial]

Do you want to know something wild about contracts?

Okay, here it goes: Even though large companies can have 90 percent (or more) of their annual revenues in contracts with suppliers and vendors, underinvestment in contract management can lead to an erosion of value equal to 9 percent of annual revenues.

In other words, the lack of investment in contract management is nothing but a huge waste of money for mid-sized and large organizations.

And one of the main reasons why this happens is the crazy amount of time that companies spend on tens of thousands of contracts every single year.

So, how can you reduce the amount of time (and resources) your organization spends on contract management? 

The answer is contract automation. 

There are many things you can automate when dealing with contracts, and today we’re going to show you one of them: Contract creation.

In this tutorial, we’ll show you how to automate contract creation so you can dedicate your time to what matters the most: Terms, conditions, and increasing revenues.

Moreover, this contract automation solution can be created with simple, affordable tools like Google Docs, Make, and one of the most popular CRMs in the market: Pipedrive. 

Before we start, sign up for a Make account, and get ready to build a life-changing contract management system in a matter of minutes.

Automated contract creation: Use case overview

There are many different settings where creating contracts automatically can benefit an organization. 

For the sake of simplicity, we’ll show a simple use case to build our solution: 

When a salesperson closes a deal, Make will create a service level agreement (SLA) document with the details of the deal, and add it to the salesperson’s CRM.

To manage the deals, we’ll use Pipedrive, as it’s popular and easy to use. However, you can replace Pipedrive for another CRM, as Make supports dozens of these.

We’ll also include a bonus automation that sends the contract to the end customer. This can help streamline the process even more, and shows how powerful and flexible Make is when it comes to automating processes.

Now, let’s jump right into the tutorial.

Step 1: Basic CRM setup

The first thing we need to know is the basic operating principle of our automated contract creation solution - and that lies within the CRM.

Pipedrive makes it very easy to create deals, move them along the sales pipeline, and mark them as “Won” or “Lost”.

Moreover, each deal card can support information such:

• Deal name

• Deal value

• Contact information of people involved in the deal 

• Account details 

Why is this important? Because we’ll be using the information in the CRM to create and populate the contracts after a deal is won - so it’s important to have it there in the first place.

Step 2: Creating the contract-generating scenario

Now that we understand the role of the CRM, we’ll create a Make scenario and add the Pipedrive CRM > Watch Deals module. 

This module will detect new deals that are marked as “Won” in the CRM.

In the configuration window of the module select “won” as the deal Status and “Object created” as the option for the Trigger when field.

See the image below for reference:

That’s all we need to configure this module, so click “OK” once done.

Step 3: Creating a contract template in Google Docs

Now we’ll create a contract template in Google Docs. 

Make will use this template to create new contracts with data from Pipedrive every time a new deal is won.

To create the template, simply head to a Google Drive folder, create a new Google Doc, and write a new contract.

The most important thing at this point is to place dynamic value tags in the contract.

These dynamic value tags contain data values that change from contract to contract, such as date, or initial fee. 

In your Google Doc, those tags will look like this: 

{{ date }}

{{ name }}

{{ initial_fee }}

For reference, here’s an example of an SLA contract with dynamic tags that will be populated with dynamic data from the CRM (upon the creation of the contract, automatically).

Step 4: Configuring the Google Docs module 

Once your Google Doc contract template is ready, head back to your Make scenario and add the Google Docs > Create a Document from a Template module next to the Pipedrive one. 

In the configuration window of the module go to “Document ID” and select the Google Doc template you have just created.

After you do that, a list of fields will appear. You’ll see one field for each dynamic tag you added to the contract template. 

This is where you can map the data elements from the Pipedrive CRM module, which in turn will populate the document fields with relevant contract data.

See the image below for reference:

So, how do you map a data element? 

Simply click on a field, and a list of data elements will appear on the side. You can map these elements just by clicking on them!

In this example, many of the contract fields need to be filled out with information that is specific to the service that is provided to the customer (such as name, deal value, and so on).

In order to have this data available, you first have to collect it in the CRM - and in Pipedrive, this means using a set of custom data fields.

It’s worth noting that most CRMs support custom data fields. 

In Pipedrive, they can be created under the Settings > Company > Data fields page.

After creating the custom data fields, it is possible to map them as data elements to the Google Doc contract template. 

Therefore, all the contract-specific data that is collected in each CRM deal card will automatically be passed to the contract template upon its generation.

To conclude configuring the Google Docs module, we need to select the Google Drive folder where we want to store the contracts we create automatically.

To achieve this, define the storage folder in the New Document’s Location field.

Step 5: Final custom data fields for Pipedrive

Before we add a final module to our scenario, it’s important to create the following custom data fields for the CRM deal cards: 

• Contract file URL (this will enable the sales reps to view the contract)

• Contract document ID

• Contract status

See the image below for reference:

Step 6: Updating Pipedrive when a new contract is created

Thanks to the custom fields we just created, we can update Pipedrive once a new contract is automatically generated by Make.

To achieve this, add the Pipedrive CRM > Update a Deal module to your scenario. This module will upload the contract file to the deal card.

In the configuration window of the module, you need to map the Deal ID data element from the Pipedrive CRM > Watch Deals module - as a way to identify the deal card which should be updated. 

Needless to say, we want to update the same deal card that the contract was generated for.

Next, map the Web View Link and Document ID data elements (obtained from the Google Docs > Create a Document from a Template module) to the Software License Agreement and Software License Agreement (Document ID) fields, respectively.

See the image below for reference:

Once the scenario is executed and the contract is generated, the data in the custom fields will look like this:

And that’s it!

Click “OK” to finish configuring the module, activate the Make scenario, and save it. 

You now have your own automated contract creation solution, which should look like this:

And thanks to it, sales representatives can click on the contract link and view the contract in their browser to make sure that the details are correct. 

Final thoughts: Contract automation, made affordable

As you can see, there’s no point in spending countless hours drafting contract after contract.

Make can take care of it all, and do it for a minimal fraction of the average salary of a legal assistant.

As a result, you will be able to:

• Dedicate more time to contract details (where money gets lost)

• Relieve your team from contract creation tasks

And all you need to get there is to sign up for Make and follow this tutorial - nice and easy!