Electronic signatures have grown in popularity over the past decade and have become the standard for getting contracts signed online. The initial adoption of eSignatures mainly involved importing your documents from various sources into web-based eSignature applications like BoldSign and then sending signature requests from there.
However, manually importing documents into electronic signature applications can feel a bit cumbersome when dealing with higher volumes. Ideally, users should be able to send eSignature requests from their existing applications without having to export documents into another application. BoldSign provides a comprehensive suite of APIs for integrating electronic signature capabilities into your existing applications.
Many SaaS applications on the market can benefit from embedding eSignature capabilities. However, many SaaS applications are multitenant, which introduces additional challenges when integrating eSignature capabilities.
A multitenant application is an application where there are at least two hierarchies of customers. For example, consider a recruitment software SaaS company, Cubeflakes. Cubeflakes’s customer is Bytesplash, a recruitment company that needs to get contracts signed by their customers who are job seekers
The challenge arises when Bytesplash needs to send contracts to job seekers under their identity. Typically, this would require Bytesplash to sign up for an account with the eSignature software provider, and that causes a couple of problems:
These reasons make integrating eSignature capabilities into multitenant SaaS applications cumbersome and expensive using most of the existing solutions available on the market today.
BoldSign provides a unique solution to this problem through a Signer Identity feature that makes onboarding seamless and comes at no additional cost. The cost difference between integrating BoldSign’s APIs versus any other solution in the market for a typical multitenant SaaS application would run into hundreds of thousands of dollars
The complete process of integrating BoldSign’s APIs into a multitenant SaaS application is explained in detail in this part of the blog. All examples shown are from the perspective of the fictional recruitment SaaS company called Cubeflakes.
Let’s assume that Bytesplash is Cubeflakes’s new customer who needs to have eSignature capabilities enabled for their new account.
The first step would be to create a new brand identity for Bytesplash, since the contracts will be sent under their identity. A brand identity includes several customization elements including brand colors and logo. Cubeflakes, the company that licenses BoldSign, would use BoldSign’s API to add a brand identity for Bytesplash under their account.
BoldSign API customers are allowed to create an unlimited number of brands so they can create a brand for each of their tenants. Your customers will be happy that their branding will be reflected when they send out any contracts.
In our example scenario, all documents will be sent under the Bytesplash branding and Bytesplash’s customers will not have any knowledge of Cubeflakes at all. This customization greatly increases confidence about the origin of the document.
The following is a screenshot of the branding that Bytesplash’s customers would see on the signing page
The next step would be to let Bytesplash customize its own document templates. Templates in BoldSign are useful for saving time and effort. We configure a document once with various form and signature fields and then reuse that document anytime we need to get the same contract signed by a different set of recipients. Most companies have set of documents that will be signed repeatedly by many of their customers, so using templates will save a lot of time.
In a multitenant SaaS app scenario, each of the tenants would need to upload their own templates and place various form fields like text boxes, checkboxes, radio buttons, and signature fields. In our example scenario, we are going to let Bytesplash’s users create a template for an offer letter within the Cubeflakes application.
The entire template configuration experience can be embedded within your application. In this case, Bytesplash will be able to drag form fields onto the document within the Cubeflakes app and then visually configure it as needed.
For legal compliance reasons, BoldSign only permits sending signature requests from verified identities. So, in our example scenario, Bytesplash’s identity needs to be verified by BoldSign before contracts can be sent out under its name. This verification is done through a simple email-based approval process. Use the following code snippet to send an approval request.
In our example scenario, Bytesplash will receive an email like the following one.
Once the tenant approves the request, Cubeflakes can send documents on behalf of its tenants.
Everything is set. Cubeflakes can send the document for signing on behalf of Bytesplash. Cubeflakes will use the created brand ID and template ID . Refer to the following code.
Once the document is sent, your tenant’s user will receive an email like the following one, requesting them to sign the document. Now, the user will be confident about the origin of the document and the identity of the signature requester, and they can sign the document with confidence.
That’s it, we have successfully integrated electronic signature capabilities into a multitenant SaaS application. The code samples that we have seen so far only showcase the signature request process. However, BoldSign also provides several other APIs to track the status of signature requests and even download the final signed document.
Latest Articles
Send eSignature documents from bubble.io using BoldSign
Create Custom Form Fields to Speed Up Document Building with BoldSign
Top 10 Use Cases of eSignatures