Forem: Vijay Amalan

Reduce eSignature Drop‑Off: Practical Ways to Improve Completion Rates

Vijay Amalan — Thu, 07 May 2026 04:06:19 +0000

If your eSignature completion rate isn’t where you want it, it is rarely because people “don’t want to sign.” More often, they intend to complete the document. Something in the experience creates friction. The email does not land, the flow feels unclear on mobile, authentication slows them down, or the signer has to jump between apps and tabs.

The good news: you don’t need to redesign everything to fix this. You can diagnose drop-off like a funnel, identify where people are getting stuck, and apply a handful of targeted improvements that typically lift completion rates quickly.

In this guide, we’ll walk through:

The eSignature funnel to pinpoint where drop-off happens
The most common causes (and what to change) at each stage
How BoldSign supports these fixes with embedded signing, templates, reminders, sender branding, custom email domain, and configurable security controls

How can you diagnose eSignature drop-off using a funnel?

Treat your signing experience like a conversion funnel so you can stop guessing and start fixing the right step.

Sent → Delivered → Opened → Started → Completed

Sent: Your system triggered the request successfully.
Delivered: The email reached the inbox (not spam/bounce).
Opened: The recipient opened the message.
Started: The recipient clicked and began signing.
Completed: The recipient finished and submitted.

Once you know where the biggest drop is, the fix usually becomes obvious.

How do you reduce eSignature drop-off step by step?

Reducing drop-off means removing small but compounding friction points. Each stage below targets a specific failure pattern.

1) How do you improve “Sent → Delivered” rates?

If your “Delivered” rate is low, your issue is not signing. It is email deliverability or sender trust.

Common causes

Sender domain looks unfamiliar or untrusted
Poor list hygiene (old/invalid emails)
Emails routed to spam or promotions tabs

Practical fixes

Use a recognizable sender name and consistent “From” identity
Tighten list hygiene and reduce bounces
Keep subject lines and copy clear and predictable (avoid spam signals)

How BoldSign helps

Branded email so recipients recognize the request and trust it
Custom email domain so signature requests come from a domain aligned with your brand (helping recognition and reducing “who is this?” hesitation)

2) How do you increase “Delivered → Opened” rates?

If delivered emails aren’t being opened, the request may not feel urgent, safe, or relevant.

Common causes

The sender name or domain is unfamiliar, triggering hesitation or distrust
The subject line is vague, generic, or looks automated
The email does not clearly explain why the recipient is receiving it
The action required is not obvious at a glance
The message blends into promotions or notification clutter

Practical fixes

Use a straightforward subject line (e.g., “Signature requested: [Document Name]”)
State the “why” in the first sentence (what it is + what they need to do)
Put the primary action clearly above the fold

How BoldSign helps

Brand-consistent including custom email content increases recognition and reduces hesitation

3) How do you reduce friction from “Opened → Started”?

This is where many flows quietly fail. People open the email, then postpone because starting feels like work.

Common causes

The user has to log in or switch apps
The signing link expires too quickly (or the rules are unclear)
The CTA is weak or the next step feels uncertain

Practical fixes

Reduce app switching wherever possible
Make the “Start signing” step immediate and predictable
Use reasonable expirations and make them clear

How BoldSign helps

Embedded signing keeps the signer inside your product or portal
Configurable expiration for embedded links so links don’t die before the signer returns

4) Started → Completed: How do you cut friction inside the document?

Once a signer starts, completion should be fast. If they start but don’t finish, the document UX is likely the problem.

Common causes

Too many fields, or too many required fields
Signatures placed late in the document (users don’t see quick progress)
Confusing labels, unclear instructions, or bad mobile layout

Practical fixes

Remove unnecessary fields; minimize required inputs
Pre-fill anything you already know (name, company, address, dates)
Place signature/initial fields earlier where appropriate
Add clear labels and hints (“Sign here,” “Initial here,” “Date auto-fills”)
Ensure a mobile-friendly layout (spacing, tap targets, field alignment)

How BoldSign helps

Templates to standardize layouts and reduce mistakes across recurring documents
Pre-fill fields in templates to minimize manual entry and speed up completion
Audit trails to support compliance and reduce disputes after signing

5) How much authentication is too much for eSignatures?

Extra authentication can protect sensitive workflows, but too much friction can dramatically reduce completion.

Common causes

Authentication applied to low risk documents where it isn’t expected
One time passwords (OTP) or access codes added without explaining the reason

Practical fixes

Apply stronger authentication only when the document warrants it
If you require OTP or access codes, make sure the signer knows why in one sentence.

How BoldSign helps

Authentication frequency settings so you can tune friction vs. assurance based on workflow needs

Why do eSignature reminders consistently increase completion rates?

Most non-completions are not rejections; they are caused by forgetfulness and busy schedules

Common causes

No follow up after the initial request
Manual reminders delayed or forgotten by senders
Signers intend to complete later but miss the deadline
Expiration dates arrive without warning
No visibility into which stage the signer is stuck in

Practical fixes

First reminder: 24–48 hours
Follow-ups: every 2–3 days (limit total reminders to avoid annoyance)
Add a final “expires soon” nudge if you use expirations

How BoldSign helps

Automatic reminders at create
Reminders via API so your product can trigger reminders based on recipient behavior and funnel stage.

What common mistakes quietly lower eSignature completion?

Many eSignature requests fail not because people refuse to sign, but because small usability issues make the process confusing or slower than expected, causing signers to stop before finishing.

Mistake	What signers experience	How to prevent it
Too many fields	Task feels longer than expected	Request only essential data
Unclear invitation	Hesitation or distrust	Explain sender and purpose clearly
No reminders	People forget	Schedule polite follow‑ups
Unclear field labels	Confusion and pauses	Use simple, descriptive labels
Unnecessary signing order	One delay blocks everyone	Enforce order only when needed

What should you verify before sending an eSignature request?

Before sending an eSignature request, confirm a small set of fundamentals that prevent avoidable delays and signer drop-off.

This checklist focuses only on configuration and setup decisions that influence whether a signer can start and finish without friction.

Use this pre send checklist:

Deliverability: Recognizable sender name, custom email domain, clean recipient list
Email clarity: Clear subject line and a visible call to action near the top of the email
Start friction: Embedded signing enabled, minimal redirects, clear and reasonable expiration timelines
Document usability: Only required fields included, known data prefilled, layout optimized for mobile
Follow up: Automatic reminders scheduled, with the first reminder sent within 24 to 48 hours

What actually improves eSignature completion in the real world

Checkout time signing: Embedded signing during a transaction completes faster than email based flows
Offer letters: Placing signature fields earlier reduces candidate hesitation and delays
Vendor onboarding: Removing duplicate or nonessential fields shortens time to completion
Low risk agreements: Using lighter authentication avoids unnecessary signer frustration
Automated reminders: Replacing manual follow ups reduces idle time between steps

These improvements focus on how people actually behave after receiving a signing request.

Final key takeaways: How reducing friction improves eSignature completion rates

Reducing eSignature drop-off is not about pushing signers harder. It is about removing avoidable friction at every stage of the signing journey. When emails are trusted, starting is effortless, documents are fast to complete, security feels appropriate, and reminders arrive at the right time, completion rates improve naturally. You do not need to redesign your workflow to see results. Treat eSignature like a funnel, identify where signers pause, and apply targeted fixes. This approach consistently increases completion without adding operational overhead.

BoldSign supports this end to end with embedded signing, reusable templates, pre filled fields, branded email delivery, flexible authentication, automated reminders, and audit ready compliance, so teams can focus on speed, trust, and completion rather than follow ups and guesswork.

If you’d like to explore more about BoldSign capabilities, sign up for a free BoldSign API account leave a comment, book a demo, or connect with our support team through the BoldSign support portal.

Webinar Show Notes: Salesforce Contract Management with BoldSign

Vijay Amalan — Wed, 06 May 2026 03:39:06 +0000

In this session, Gayathri Annamalai, Software Developer at BoldSign, walks through how organizations can eliminate manual document steps by managing the entire eSignature lifecycle inside Salesforce. Instead of exporting data, switching tools, or tracking status manually, teams can send agreements, monitor progress, and store signed documents directly from Salesforce records.

If you missed the live session or would like to watch it again, the recording is embedded on this page and is also available on our YouTube channel.

Webinar recap

The webinar opened with a common challenge many Salesforce teams face today. Contract workflows often involve copying data from Salesforce into documents, sending them through separate eSignature tools, and manually updating status afterward. This back and forth introduces delays, duplicate work, and a lack of visibility.

Gayathri then introduced the BoldSign Salesforce integration and explained how it brings eSignature workflows directly into Salesforce. She demonstrated how admins enable the integration once at the account level and how users work entirely within Salesforce afterward.

The live demo showed how templates and field mapping automatically prefill Salesforce data into documents, ensuring consistency and reducing errors. The session also highlighted how BoldSign Lightning Components can be added to Accounts, Contacts, Leads, and Opportunities, allowing users to send and track documents without navigating away from the record they are working on.

Finally, the webinar covered real-time document tracking and the automatic storage of completed agreements back into Salesforce, keeping Salesforce as the single source of truth.

Highlights

Enable and configure the BoldSign Salesforce integration with a one time admin setup
Use templates and field mapping to automatically prefill Salesforce data
Add BoldSign Lightning Components to Salesforce record pages
Send documents directly from Salesforce without exporting files
Track document status in real-time inside Salesforce
Automatically save signed documents back to Salesforce records

Key takeaways

Configure the BoldSign Salesforce integration once as an admin
Eliminate manual data entry with templates and field mapping
Send and manage eSignatures directly from Salesforce records
Maintain full visibility into document status without switching tools
Keep signed documents automatically stored in Salesforce

Helpful resources

Learn more about BoldSign for Salesforce
Explore BoldSign Integrations
View Salesforce Integration Documentation
Contact BoldSign Support
Start a free trial

Related blogs

Note: This blog was originally published at boldsign.com

Introducing BoldSign’s Free Phone Number QR Code Generator

Vijay Amalan — Tue, 05 May 2026 03:47:12 +0000

Phone Number QR codes make communication effortless. With a single scan, users can open their phone dialer with your number already filled in and ready to call. This simple upgrade eliminates typing errors, speeds up response time, and increases the chances of customers connecting with you instantly.

With BoldSign’s free Phone Number QR code generator, you can convert any phone number into a scannable QR code in seconds. No sign up, no watermark, no tracking, and no limits. This guide covers everything you need to know, including what a Phone Number QR code is, how it works, and all the best ways to use it effectively.

What is a Phone Number QR code?

A Phone Number QR code is a scannable code that opens the phone dialer with your number prefilled when someone scans it with their smartphone camera. One tap places the call.

You can link to:

A personal number
A business contact number
A support or helpdesk number• A service hotline
A campaign-specific call number

Why it matters: It removes the friction of typing digits manually and reduces errors dramatically.

Why use a Phone Number QR code?

A Phone Number QR code makes starting a call quick, simple, and frustration-free. It is effective across both online and offline channels where you want instant customer contact.

Key benefits

Instant calling – One scan opens your number in the dialer. Faster communication and fewer missed opportunities.
Higher conversions – Ideal for reservation counters, brochures, and event booths where customers decide quickly.
Better customer experience – No typing, no searching, no mistakes.
Modern presentation – Add QR codes to business cards, brochures, receipts, and printed materials to upgrade your brand presence.
Mobile first convenience – All modern smartphones support QR code scanning with the native camera.

How to create Phone Number QR code for free?

Creating your Phone Number QR code takes only a few seconds.

What you’ll need

Your phone number
A browser on any device

Step by step

Enter your phone number Type the number you want users to call instantly.
Customize your QR code

Adjust:
- Pattern color
- Background color
- QR code size
Download and share

Export your QR code as:
- PNG
- JPEG
- SVG

Phone Number QR code generator

Why choose BoldSign’s Phone Number QR code generator

BoldSign’s tool is built for speed, security, and ease of use.

100% free forever: No subscriptions, no hidden fees, and no watermarks.
Privacy first: Your number is processed directly in your browser. Nothing is stored or sent anywhere.
Instant results: Generate high quality QR codes in seconds.
Works on all devices: Windows, macOS, Linux, iOS, and Android. No apps are needed.

Best ways to use Phone Number QR code

Phone Number QR codes can improve customer communication everywhere you place them.

Business cards: Make contacting you easier with a quick scan.
Storefronts and counters: Let walk-in customers call for assistance or reservations.
Printed marketing: Add QR codes to flyers, banners, posters, and brochures.
Events and exhibitions: Great for booths, badges, and digital screens where quick contact matters.
Online communication: Add your QR code to email signatures, social media graphics, and presentations.

Conclusion

A Phone Number QR code makes calling you faster, simpler, and error-free. It removes extra steps, increases customer accessibility, and lets people reach you instantly from any medium, whether it is printed or digital.

Create your Phone Number QR code with BoldSign today and make it easier for people to connect with you in seconds.

Ready to simplify your document workflows? Sign up for a free 30-day trial or connect with our support team for a personalized demo.

Related blogs

Note: This blog was originally published at boldsign.com

Construction Contract Basics: What Every Project Agreement Should Include

Vijay Amalan — Mon, 04 May 2026 04:11:53 +0000

A construction contract is the document that defines the project scope, responsibilities, timeline, payment terms, and change rules so everyone knows exactly what to do and how disputes will be handled. The strongest construction agreements prevent misunderstandings early by clearly documenting who is involved, what work will be done, when it will happen, how payments work, and what to do when something changes. 

In this guide, you’ll learn the must-have components of a construction contract, the most common agreement challenges, and a simple approval workflow. You’ll also see how BoldSign helps teams execute contracts faster with templates, signing order, reminders, tracking, and audit trails. 

Why a solid construction contract matters 

A construction contract is more than a formality. It protects the project by creating a clear, enforceable framework for: 

Communication between owners, contractors, architects, subcontractors, and suppliers 
Legal protection against misunderstandings, claims, and disputes 
Scope clarity for deliverables, materials, and quality standards 
Timeline control with milestones and delay handling 
Payment clarity including retainage, progress billing, and approvals 
Change management when the scope or schedule shifts 
Safety and compliance alignment with local regulations and requirements

A strong contract reduces risk, improves coordination, and helps keep the project on schedule and on budget. 

Common challenges in construction agreements 

Construction projects involve many stakeholders and moving parts. The most frequent issues usually come from unclear terms, delays, and inconsistent approvals. 

Delays and scheduling conflicts 

Weather, labor shortages, or supply disruptions can trigger timeline disputes and added costs. 

How to reduce risk 

Define delay allowances and notice requirements 
Track approvals and hold signers accountable with reminders and visibility

Payment disputes 

Disagreements over amounts due, timing, or work quality can impact cash flow and lead to liens. 

How to reduce risk 

Specify payment milestones, retainage, and approval conditions 
Maintain clear records of approvals and signed terms

Contract interpretation issues 

Ambiguous wording around scope, responsibilities, or change control can cause conflicts. 

How to reduce risk 

Standardize contract language using templates 
Reference drawings, specifications, and addenda clearly

Changed conditions or scope creep 

Design changes and site surprises often cause cost and timeline disputes. 

How to reduce risk 

Define a formal change order process 
Require documented approvals before work proceeds

Subcontractor and quality disputes 

Workmanship issues and coordination gaps can escalate quickly. 

How to reduce risk 

Assign responsibility clearly 
Keep sign-offs and confirmations traceable with audit-ready records

Most disputes come from unclear scope, unclear payment terms, unmanaged changes, and missing approval evidence. 

Essential components of a construction contract 

Below are the core elements every construction contract should include. These are the sections that make agreements clear, enforceable, and easier to manage. 

Identification of parties 

Include full legal names, addresses, and roles for: 

Owner 
General contractor 
Subcontractors (as applicable) 
Architects, engineers, or designers (as applicable)

Scope of work 

Define what work will be performed and how it will be measured. 

Include: 

Project tasks and deliverables 
Materials and workmanship standards 
Drawings, specifications, and addenda references 
Exclusions and assumptions to prevent scope creep

Project timeline and schedule 

Outline the schedule and how delays are handled. 

Include: 

Start date and substantial completion date 
Milestones and deliverable deadlines 
Delay notice requirements 
Consequences for delays if applicable

Payment terms and schedule 

Clarify how and when payment happens. 

Include: 

Total contract value or pricing structure 
Progress payment schedule 
Retainage percentage and release conditions 
Invoicing requirements and approval process 
Late payment terms if applicable

Change order process 

Define how scope, cost, and timeline changes are approved. 

Include: 

What qualifies as a change order 
Required documentation 
Approval roles and signing order 
How costs and schedule changes are calculated

Responsibilities and warranties 

Assign responsibilities clearly and protect the project quality. 

Include: 

Responsibilities for owner, contractor, and subcontractors 
Workmanship and materials warranties 
Insurance requirements and coverage levels

Dispute resolution 

Set a clear path to handle conflicts. 

Include: 

Mediation, arbitration, or litigation process 
Governing law and jurisdiction 
Notice and escalation steps

Termination clauses 

Define when and how the agreement can end. 

Include: 

Termination for cause and termination for convenience 
Cure periods and notice requirements 
Final payment and materials handling

Force majeure and insurance 

Cover uncontrollable events and risk protection. 

Include: 

Force majeure definition and impacts on schedule 
Required insurance for all parties 
Safety and incident reporting expectations

Contract documents list 

List every document that forms the agreement. 

Include: 

General conditions and special conditions 
Drawings and specifications 
Change orders and addenda 
Schedules and exhibits

 These components reduce ambiguity and create a clear rulebook for handling delays, payments, and changes. 

Key steps in the contract approval workflow 

A typical construction contract approval workflow looks like this. 

Step 1: Draft the contract 

Build from a standardized template 
Include project-specific scope, schedule, and payment terms

Step 2: Review 

Share with legal, project stakeholders, and required approvers 
Confirm compliance requirements and risk terms

Step 3: Negotiate and revise 

Address feedback 
Finalize scope and change control language 
Confirm pricing, milestones, and retainage

Step 4: Approve and sign 

Route to signers in the correct order 
Ensure every party signs the final version

Step 5: Execute and store 

Distribute the signed copy 
Store securely with audit-ready records

The approval process fails most often when versions split and signing order is unclear. 

How BoldSign improves construction contract approvals 

BoldSign streamlines contract execution for construction teams with features designed for multi-party workflows. 

Templates 

Use reusable contract templates to standardize common construction agreements and speed up drafting.

With document template, teams can:

Draft contracts faster
Reduce missing fields and costly errors
Standardize contract language across projects

Templates ensure consistency across bids, change orders, and subcontractor agreements.

create new template

E-signatures 

Enable secure, legally compliant eSignatures for on‑site teams and remote stakeholders.

With eSignature, construction teams benefit from:

Faster contract turnaround
Reduced reliance on paper and printing
Mobile‑friendly signing from any device

Signing order and role routing 

Automatically route documents to the right stakeholders in sequence or parallel using signing order and role‑based workflows.

Common flows include: 

Owner approval followed by contractor and subcontractor
Legal review before final client sign‑off

This ensures approvals happen in the correct order without manual coordination.

Automated reminders 

Reduce delays by automatically following up with pending signers. 

Real-time tracking 

Monitor contract progress from send to completion using a centralized dashboard with real-time visibility through document tracking.

Identify approval bottlenecks early
Monitor deadlines more effectively
Reduce status check emails and calls

Audit trails 

Maintain tamper‑evident records for compliance and accountability with the availability of detailed audit trails.

Who signed the contract
When each signature was completed
All actions taken during the approval process

This is especially valuable for dispute resolution and regulatory audits.

Audit Trail

Conclusion 

A solid construction contract is a roadmap for project success. When your contract clearly defines scope, timelines, payments, responsibilities, and change control, you reduce disputes and keep work moving. 

With digital approvals and eSignatures, teams can execute contracts faster, reduce manual coordination, and maintain audit-ready records. If you manage complex construction workflows, BoldSign can help standardize and speed up contract approvals. 

Related blogs

Note: This blog was originally published at boldsign.com

BoldSign Formula Fields: Automate Calculations in eSignature Documents

Vijay Amalan — Thu, 30 Apr 2026 04:04:47 +0000

Manually calculating values in documents can be time-consuming and leave you prone to error, especially when dealing with contracts, invoices, or agreements that require dynamic values like totals, taxes, or discounts. You might struggle to ensure accuracy and consistency across multiple signers and documents. Repetitive manual entry of calculated fields like subtotals, taxes, and totals increases the risk of human error, which can lead to compliance issues or financial discrepancies. It can also cause delays in document turnaround because calculations need verification before sending.

What if you could automate these calculations directly within your e-signature workflow? That’s where BoldSign formula fields come in.

What problems do formula fields solve in eSignature documents?

With formula fields, you can define dynamic calculations directly in your e-signature documents using the BoldSign API.

Key benefits include:

Automated calculations: You can perform real-time calculations like totals, taxes, discounts, or custom formulas based on other field values.
Error reduction: Reduce manual entry errors by computing values automatically, ensuring consistency and accuracy.
Improved user experience: Signers don’t need to do math themselves. The document updates instantly as they fill in fields.
Dynamic content: You can create smart documents that adapt based on user input, making them more interactive and professional.
Time savings: Save time for both senders and signers by eliminating the need for manual calculations or post-signing edits.
Supports complex logic: Use functions like IF for advanced scenarios.

How do BoldSign formula fields work?

These formulas are built using supported operators, functions, and fields without storing static data. As signers enter values into the form, the formula fields in the document recalculate instantly. This ensures accurate results and reduces manual effort.

Which fields, operators, and functions are supported?

BoldSign formula fields support various form fields, operators, and functions to help you streamline arithmetic calculations in your e-signature documents.

How do you add formula fields to a document API request?

When creating or sending a document or template via the BoldSign API, you can add formula fields programmatically by including them in the formFields array of your request payload.

Here’s what to include:

fieldType: Set to “Formula” to indicate it’s a formula field.
formulaFieldSettings: This object contains:
- formulaExpression: The actual calculation logic (e.g., “[textbox1] – [textbox2]”). Use only the field ID in your formula expression.
- decimalPrecision: The number of decimal places to show in the result.

What does a vehicle sales agreement example look like with formula fields?

Let’s look at a practical example. Suppose you’re sending a vehicle sales agreement and want the signer to enter:

Total vehicle value → [Textbox1].
Deposit amount → [Textbox2].

From these inputs, you want to:

Calculate the remaining balance.

Formula: Balance = [Textbox1]- [Textbox2]

Set the Payment Date to be seven days from the signing date.

Formula: PaymentDate = AddDays([SigningDate], 7)

(Payment should be made 7 days from the signing date.)

When the document is sent via the BoldSign API, the balance and payment date are automatically calculated in real time as the signer fills in the values. This eliminates manual math, reduces errors, and improves the signing experience.

Here are example code snippets for sending a signature request with formula fields via API.

cURL

    curl -X 'POST' \
      'https://api.boldsign.com/v1/document/send' \
      -H 'accept: application/json' \
      -H 'X-API-KEY: {your API key}' \
      -H 'Content-Type: application/json' \
      -d '{
        "Signers": [
          {
            "Name": "Hanky",
            "EmailAddress": " david@cubeflakes.com",
            "SignerType": "Signer",
            "DeliveryMode": "Email",
            "FormFields": [
              {
                "Id": "signature1",   
                "FieldType": "Signature",
                "PageNumber": 1,
                "Bounds": { "X": 50, "Y": 50, "Width": 100, "Height": 50 },
                "IsRequired": true
              },
              {
                "Id": "textbox1",              // TextBox 1
                "FieldType": "TextBox",
                "PageNumber": 1,
                "Bounds": { "X": 50, "Y": 100, "Width": 100, "Height": 30 },
                "IsRequired": true,
                "ValidationType": "NumbersOnly"
              },
              {
                "Id": "textbox2",          // TextBox 2
                "FieldType": "TextBox",
                "PageNumber": 1,
                "Bounds": { "X": 200, "Y": 100, "Width": 100, "Height": 30 },
                "IsRequired": true,
                "ValidationType": "NumbersOnly"
              },
              {
                "Id": "SigningDate",        // Signing Date
                "FieldType": "DateSigned",
                "PageNumber": 1,
                "Bounds": { "X": 200, "Y": 200, "Width": 125, "Height": 25 },
                "IsRequired": true
              },
              {
                "Id": "PaymentDate",     # Payment Date (7 days after Signing Date)
                "FieldType": "Formula",
                "PageNumber": 1,
                "Bounds": { "X": 50, "Y": 200, "Width": 200, "Height": 30 },
                "FormulaFieldSettings": {
                  "FormulaExpression": "AddDays([SigningDate],7)",
                }
              },
              {
                "Id": "Balance",   // Balance (Formula)
                "FieldType": "Formula",
                "PageNumber": 1,
                "Bounds": { "X": 50, "Y": 250, "Width": 200, "Height": 30 },
                "FormulaFieldSettings": {
                  "FormulaExpression": "[textbox1] - [textbox2]",
                  "DecimalPrecision": 1
                }
              }
            ],
            "Locale": "EN"
          }
        ],
        "ExpiryDays": 30,
        "Files": [
          "data:application/pdf;base64,JVBERi0xLjcKJcfs..." 
        ],
        "Title": "Vehicle Sales Agreement",
        "ExpiryDateType": "Days",
        "ExpiryValue": 60,
        }
      }'

    var apiClient = new ApiClient("https://api.boldsign.com", "Your API Key");
                    var documentClient = new DocumentClient(apiClient);

                    // Define all form fields
                    List<FormField> formField = new List<FormField>
                    {
                        // Signature field
                        new FormField(
                            id: "Signature",
                            type: FieldType.Signature,
                            pageNumber: 1,
                            bounds: new Rectangle(x: 50, y: 50, width: 200, height: 30)),

                        // TextBox 1
                        new TextBoxField(
                            id: "textbox1",
                            validationType: BoldSign.Model.ValidationType.NumbersOnly,
                            pageNumber: 1,
                            bounds: new Rectangle(x: 50, y: 100, width: 100, height: 30),
                            isRequired: true),

                        // TextBox 2
                        new TextBoxField(
                            id: "textbox2",
                            validationType: BoldSign.Model.ValidationType.NumbersOnly,
                            pageNumber: 1,
                            bounds: new Rectangle(x: 200, y: 100, width: 100, height: 30),
                            isRequired: true),

                        // Signing date
                        new FormField(
                            id: "SigningDate",
                            type: FieldType.DateSigned,
                            pageNumber: 1,
                            bounds: new Rectangle(x: 200, y: 200, width: 125, height: 25),
                            isRequired: true),

                        // Payment date
                        new FormField(
                            id: "PaymentDate",
                            type: FieldType.Formula,
                            pageNumber: 1,
                            bounds: new Rectangle(x: 50, y: 200, width: 200, height: 30),
                            isRequired: true
                            ),

                        // Balance (formula)
                        new FormField(
                            id: "Balance",
                            type: FieldType.Formula,
                            pageNumber: 1,
                            bounds: new Rectangle(x: 50, y: 250, width: 200, height: 30),
                            isRequired: true
                            )
                    };

                    formField[4].FormulaFieldSettings= new FormulaFieldSettings
                    {
                        FormulaExpression = "AddDays([SigningDate],7)",
                    };
                    formField[5].FormulaFieldSettings = new FormulaFieldSettings
                    {
                        FormulaExpression = "[textbox1] - [textbox2]",
                        DecimalPrecision = 1
                    };

                    // Document details
                    var documentDetails = new SendForSign
                    {
                        Title = "Agreement",
                        Signers = new List<DocumentSigner>
                        {
                            new DocumentSigner(
                                signerName: "David",
                                signerType: SignerType.Signer,
                                signerEmail: "david@cubeflakes.com",
                                formFields: formField)
                        },
                        Files = new List<IDocumentFile>
                        {
                            new DocumentFilePath
                            {
                                ContentType = "application/pdf",
                                FilePath = "Your File Path.pdf",
                            }
                        },
                    };

                    // Send document
                    var documentCreated = documentClient.SendDocument(documentDetails);
                    Console.WriteLine($"Document sent successfully. Document ID: {documentCreated?.DocumentId}");

Python

    import boldsign
    configuration = boldsign.Configuration(api_key="Your API Key ")
    with boldsign.ApiClient(configuration) as api_client:
        document_api = boldsign.DocumentApi(api_client)
        # Signature field
        signature_field = boldsign.FormField(
            fieldType="Signature",
            pageNumber=1,
            bounds=boldsign.Rectangle(x=50, y=50, width=200, height=25)
        )
        # Total vehicle value
        textbox1 = boldsign.FormField(
            id="textbox1",
            fieldType="TextBox",
            pageNumber=1,
            bounds=boldsign.Rectangle(x=50, y=100, width=100, height=30),
            validationType="NumbersOnly",
            isRequired=True
        )
        # Deposit amount
        textbox2 = boldsign.FormField(
            id="textbox2",
            fieldType="TextBox",
            pageNumber=1,
            bounds=boldsign.Rectangle(x=200, y=100, width=150, height=30),
            validationType="NumbersOnly",
            isRequired=True
        )
    # Balance formula
    formula_balance = boldsign.FormField(
        id="FormulaBalance",
        fieldType="Formula",
        pageNumber=1,
        bounds=boldsign.Rectangle(x=50, y=150, width=200, height=30),
        formulaFieldSettings=boldsign.FormulaFieldSettings(
            formulaExpression="[textbox1] - [textbox2]", 
            decimalPrecision=1
        )
    )
    #  Signing date
    signing_date_field = boldsign.FormField(
        id="SigningDate",
        fieldType="DateSigned",
         isRequired=True,
        pageNumber=1,
        bounds=boldsign.Rectangle(x=50, y=200, width=100, height=30),

    )
    # Payment date (seven days after signing date)
    payment_date_field = boldsign.FormField(
        id="PaymentDate",
        fieldType="Formula",
        pageNumber=1,
        bounds=boldsign.Rectangle(x=50, y=250, width=200, height=30),
        formulaFieldSettings=boldsign.FormulaFieldSettings(
            formulaExpression="AddDays([SigningDate], 7)",
        )
    )
    # Signer with all fields
    document_signer = boldsign.DocumentSigner(
        name="David",
        emailAddress="david@cubeflakes.com",
        signerType="Signer",
        formFields=[
            signature_field,
            textbox1,
            textbox2,
            formula_balance,
            signing_date_field,
            payment_date_field
        ]
    )
    send_for_sign = boldsign.SendForSign(
        title="Vehicle Sales Agreement",
        files=["Your file path.pdf"],
        signers=[document_signer]
    )
    document_created = document_api.send_document(send_for_sign)

PHP

    <?php require_once "vendor/autoload.php";
    use BoldSign\Configuration;
    use BoldSign\Api\DocumentApi;
    use BoldSign\Model\{
        FormField,
        Rectangle,
        DocumentSigner,
        SendForSign,
        FileInfo,
        FormulaFieldSettings,
        EditableDateFieldSettings
    };
    $config = new Configuration();
    $config->setApiKey('Your API Key');
    $document_api = new DocumentApi($config);
    // Signature field
    $signatureField = new FormField();
    $signatureField->setFieldType('Signature');
    $signatureField->setPageNumber(1);
    $signatureField->setBounds(new Rectangle([50, 50, 200, 25]));
    // Total vehicle value
    $textbox1 = new FormField();
    $textbox1->setId('textbox1');
    $textbox1->setFieldType('TextBox');
    $textbox1->setPageNumber(1);
    $textbox1->setBounds(new Rectangle([50, 100, 100, 30]));
    $textbox1->setValidationType('NumbersOnly');
    $textbox1->setIsRequired(true);
    // Deposit amount
    $textbox2 = new FormField();
    $textbox2->setId('textbox2');
    $textbox2->setFieldType('TextBox');
    $textbox2->setPageNumber(1);
    $textbox2->setBounds(new Rectangle([200, 100, 100, 30]));
    $textbox2->setValidationType('NumbersOnly');
    $textbox2->setIsRequired(true);
    // Signing date
    $signingDateField = new FormField();
    $signingDateField->setId('SigningDate');
    $signingDateField->setFieldType('DateSigned');
    $signingDateField->setPageNumber(1);
    $signingDateField->setBounds(new Rectangle([50, 200, 100, 30]));
    $signingDateField->setIsRequired(true);
    // Payment date (seven days after signing date)
    $paymentDate = new FormField();
    $paymentDate->setId('PaymentDate');
    $paymentDate->setFieldType('Formula');
    $paymentDate->setPageNumber(1);
    $paymentDate->setBounds(new Rectangle([50, 200, 200, 30]));
    $paymentSettings = new FormulaFieldSettings();
    $paymentSettings->setFormulaExpression('AddDays([SigningDate],7)');
    $paymentDate->setFormulaFieldSettings($paymentSettings);
    // Balance formula
    $balanceField = new FormField();
    $balanceField->setId('Balance');
    $balanceField->setFieldType('Formula');
    $balanceField->setPageNumber(1);
    $balanceField->setBounds(new Rectangle([50, 250, 200, 30]));
    $balanceSettings = new FormulaFieldSettings();
    $balanceSettings->setFormulaExpression('[textbox1] - [textbox2]'); 
    $balanceSettings->setDecimalPrecision(1);
    $balanceField->setFormulaFieldSettings($balanceSettings);
    // Signer
    $document_signer = new DocumentSigner();
    $document_signer->setName("David");
    $document_signer->setEmailAddress("david@cubeflakes.com");
    $document_signer->setSignerType("Signer");
    $document_signer->setFormFields([
        $signatureField, $textbox1, $textbox2, $signingDateField, $paymentDate, $balanceField
    ]);
    $send_for_sign = new SendForSign();
    $send_for_sign->setFiles(['Non Disclosure Agreement.pdf']);
    $send_for_sign->setSigners([$document_signer]);
    $send_for_sign->setTitle('Vehicle Sales Agreement');
    // Send document
    $document_created = $document_api->sendDocument($send_for_sign);

Java

    ApiClient client = Configuration.getDefaultApiClient();
            client.setApiKey("Your API Key");
            DocumentApi documentApi = new DocumentApi(client);
            // Signature field
            FormField signatureField = new FormField();
            signatureField.setFieldType(FormField.FieldTypeEnum.SIGNATURE);
            signatureField.setPageNumber(1);
            signatureField.setBounds(new Rectangle().x(100f).y(100f).width(100f).height(50f));
            // Total vehicle value
            FormField vehicleValue = new FormField();
            vehicleValue.setId("textbox1");
            vehicleValue.setFieldType(FormField.FieldTypeEnum.TEXT_BOX);
            vehicleValue.setPageNumber(1);
            vehicleValue.setBounds(new Rectangle().x(50f).y(50f).width(120f).height(30f));
            vehicleValue.setValidationType(FormField.ValidationTypeEnum.NUMBERS_ONLY);
            // Deposit amount
            FormField depositAmount = new FormField();
            depositAmount.setId("textbox2");
            depositAmount.setFieldType(FormField.FieldTypeEnum.TEXT_BOX);
            depositAmount.setPageNumber(1);
            depositAmount.setBounds(new Rectangle().x(200f).y(50f).width(120f).height(30f));
            depositAmount.setValidationType(FormField.ValidationTypeEnum.NUMBERS_ONLY);
            // Signing date 
            FormField signingDate = new FormField();
            signingDate.setId("SigningDate");
            signingDate.setFieldType(FormField.FieldTypeEnum. DATE_SIGNED); 
            signingDate.setPageNumber(1);
            signingDate.setBounds(new Rectangle().x(50f).y(100f).width(180f).height(30f));
            signingDate.setDateFormat("MM/dd/yyyy"); 
            // Payment date
            FormField paymentDate = new FormField();
             paymentDate.setId("PaymentDate");
             paymentDate.setFieldType(FormField.FieldTypeEnum.FORMULA);
             paymentDate.setPageNumber(1);
             paymentDate.setBounds(new Rectangle().x(50f).y(140f).width(180f).height(30f));
            FormulaFieldSettings paymentSettings = new FormulaFieldSettings();
             paymentSettings.setFormulaExpression("AddDays([SigningDate],7)");
             paymentDate.setFormulaFieldSettings( paymentSettings);
            // Balance 
            FormField balanceField = new FormField();
            balanceField.setId("Balance");
            balanceField.setFieldType(FormField.FieldTypeEnum.FORMULA);
            balanceField.setPageNumber(1);
            balanceField.setBounds(new Rectangle().x(50f).y(200f).width(200f).height(30f));
            FormulaFieldSettings balanceSettings = new FormulaFieldSettings();
            balanceSettings.setFormulaExpression("[textbox1] - [textbox2]");  
            balanceSettings.setDecimalPrecision(2);
            balanceField.setFormulaFieldSettings(balanceSettings);
            // Signer
            DocumentSigner signer = new DocumentSigner();
            signer.setName("David");
            signer.setEmailAddress("david@cubeflakes.com");
            signer.setSignerType(DocumentSigner.SignerTypeEnum.SIGNER);
            signer.setFormFields(Arrays.asList(
                    signatureField,
                    vehicleValue,
                    depositAmount,
                    signingDate,
                    paymentDate,
                    balanceField
            ));
            // Send document
            SendForSign sendForSign = new SendForSign();
            File file = new File("Your file path.pdf"); 
            sendForSign.setFiles(Arrays.asList(file));
            sendForSign.setSigners(Arrays.asList(signer));
            sendForSign.setTitle("Vehicle Sales Agreement");
            DocumentCreated documentCreated = documentApi.sendDocument(sendForSign);
            System.out.println("Document created: " + documentCreated.getDocumentId());

Node js

    import { DocumentApi, DocumentSigner, FormField, Rectangle, SendForSign } from "boldsign";
    import * as fs from 'fs';

    const documentApi = new DocumentApi();
    documentApi.setApiKey("Your API KEY");

    // Signature field
    const signatureField = new FormField();
    signatureField.fieldType = FormField.FieldTypeEnum.Signature;
    signatureField.pageNumber = 1;
    signatureField.bounds = new Rectangle();
    signatureField.bounds.x = 50;
    signatureField.bounds.y = 50;
    signatureField.bounds.width = 200;
    signatureField.bounds.height = 25;

    // Total vehicle value
    const textbox1 = new FormField();
    textbox1.id = "textbox1";
    textbox1.fieldType = FormField.FieldTypeEnum.TextBox;
    textbox1.pageNumber = 1;
    textbox1.bounds = new Rectangle();
    textbox1.bounds.x = 50;
    textbox1.bounds.y = 100;
    textbox1.bounds.width = 100;
    textbox1.bounds.height = 30;
    textbox1.validationType = "NumbersOnly";
    textbox1.isRequired = true;

    // Deposit amount
    const textbox2 = new FormField();
    textbox2.id = "textbox2";
    textbox2.fieldType = FormField.FieldTypeEnum.TextBox;
    textbox2.pageNumber = 1;
    textbox2.bounds = new Rectangle();
    textbox2.bounds.x = 200;
    textbox2.bounds.y = 100;
    textbox2.bounds.width = 150;
    textbox2.bounds.height = 30;
    textbox2.validationType = "NumbersOnly";
    textbox2.isRequired = true;

    // Balance formula
    const formulaBalance = new FormField();
    formulaBalance.id = "FormulaBalance";
    formulaBalance.fieldType = FormField.FieldTypeEnum.Formula;
    formulaBalance.pageNumber = 1;
    formulaBalance.bounds = new Rectangle();
    formulaBalance.bounds.x = 50;
    formulaBalance.bounds.y = 150;
    formulaBalance.bounds.width = 200;
    formulaBalance.bounds.height = 30;
    formulaBalance.formulaFieldSettings = {
        formulaExpression: "[textbox1] - [textbox2]",
        decimalPrecision: 1
    };

    // Signing date
    const signingDateField = new FormField();
    signingDateField.id = "SigningDate";
    signingDateField.fieldType = FormField.FieldTypeEnum.DateSigned;
    signingDateField.isRequired = true;
    signingDateField.pageNumber = 1;
    signingDateField.bounds = new Rectangle();
    signingDateField.bounds.x = 50;
    signingDateField.bounds.y = 200;
    signingDateField.bounds.width = 100;
    signingDateField.bounds.height = 30;

    // Payment date (seven days after signing date)
    const paymentDateField = new FormField();
    paymentDateField.id = "PaymentDate";
    paymentDateField.fieldType = FormField.FieldTypeEnum.Formula;
    paymentDateField.pageNumber = 1;
    paymentDateField.bounds = new Rectangle();
    paymentDateField.bounds.x = 50;
    paymentDateField.bounds.y = 250;
    paymentDateField.bounds.width = 200;
    paymentDateField.bounds.height = 30;
    paymentDateField.formulaFieldSettings = {
        formulaExpression: "AddDays([SigningDate], 7)",
    };
    // Signer with all fields
    const documentSigner = new DocumentSigner();
    documentSigner.name = "David";
    documentSigner.emailAddress = "david@cubeflakes.com";
    documentSigner.signerType = DocumentSigner.SignerTypeEnum.Signer;
    documentSigner.formFields = [
        signatureField,
        textbox1,
        textbox2,
        formulaBalance,
        signingDateField,
        paymentDateField
    ];

    const files = fs.createReadStream("Your File Path.pdf");

    const sendForSign = new SendForSign();
    sendForSign.title = "Vehicle Sales Agreement";
    sendForSign.signers = [documentSigner];
    sendForSign.files = [files];

    const documentCreated = documentApi.sendDocument(sendForSign);

In the code examples above, replace the placeholders Your API Key and file path with your actual API key and the correct file path. In the formula expression section, use only the field ID. Once executed, the document will be sent to the specified signers, and any formula fields will automatically calculate values based on their input in real time, as shown below.

Formula Fields

What best practices help formula fields work reliably?

Keep formulas simple: Avoid overly complex expressions for clarity.
Validate inputs: Use NumbersOnly or other validation types.
Use decimal precision wisely: Match financial standards in your industry.
Test templates: Send sandbox documents to confirm formulas work as expected.
Think about the user experience: Place formula fields logically so signers see results immediately.

Conclusion

Using formula fields via API brings a new level of automation to your e-signature workflows. Whether you’re in sales, finance, HR, or legal, this feature can help you deliver smarter, faster, and more reliable documents.

Ready to automate your document calculations? Try out formula fields with BoldSign today!

Sign up for a free sandbox account and explore our developer documentation to learn more about our APIs. For any assistance, visit our support portal to connect with our team.

Related blogs

Note: This blog was originally published at boldsign.com

ASP.NET Core Minimal APIs: When to Use Them and When Not To Use Them

Vijay Amalan — Wed, 29 Apr 2026 03:44:33 +0000

Minimal APIs are an endpoint-first way to build HTTP APIs in ASP.NET Core by mapping routes directly to handlers (no controllers required). They’re best for teams building small-to-medium, bounded services (microservices, BFFs, webhooks, internal APIs) that want fast iteration with less ceremony, as long as you add structure early. They solve the “too much framework for a small API” problem, and they matter because choosing the wrong model (or letting Program.cs become a dumping ground) creates long-term maintenance pain.

What decision should you make: Minimal APIs or Controllers?

Use this checklist and pick the first match.

Choose Minimal APIs when your API is bounded and you can enforce conventions

You’re building a focused service boundary (webhooks, microservice, BFF, internal tool API).
You can enforce a module convention (route groups + one file per feature).
Your team likes explicit routing and fluent metadata (OpenAPI tags, response types).
You want cross-cutting behavior via middleware + endpoint filters rather than MVC filters.

Choose Controllers when the API surface is large or the team is large

You expect many endpoints across multiple domains/features.
You rely heavily on attribute-driven conventions (routing/filters/versioning patterns).
Many developers contribute and you need high discoverability via familiar conventions.
Your org already has controller-first templates, libraries, or standards.

Checkpoint: If you can’t commit to a module convention on day 1, controllers are usually the safer default.

What will you build in this guide?

You’ll build a production-shaped Minimal API starter with one clear outcome:

End result: A Minimal API that’s structured with route groups + feature modules, uses endpoint-filter validation, returns consistent Problem Details errors, exposes OpenAPI docs, and is verifiable with curl + an integration test.

What prerequisites do you need before starting?

.NET SDK installed
Basic C# knowledge
Terminal access (PowerShell/Bash)
Optional: Postman/Insomnia

Checkpoint: dotnet –version prints a version successfully.

How does a Minimal API request flow work in production?

A[HTTP Request] –> B[Middleware pipeline]

B –> C[Routing selects endpoint]

C –> D[Endpoint filters (optional)]

D –> E[Handler runs]

E –> F[Result writes response (JSON, status code)]

F –> G[HTTP Response]

Checkpoint: You can point to exactly where you’ll put (1) global behavior (middleware), (2) per-feature behavior (endpoint filters), and (3) business orchestration (handlers).

How do you avoid a giant Program.cs with Minimal APIs?

Use a feature-module convention:

Program.cs only wires dependencies, middleware, and “maps modules”
Endpoints/Endpoints.cs defines routes for a feature via a route group
Infrastructure/ holds cross-cutting filters (validation, correlation, etc.)
Services/ holds business logic (handlers stay thin)

Checkpoint: You can add a new feature by creating one new Endpoints/*Endpoints.cs file, without touching existing endpoint files.

How do you build the production starter step by step?

1) How do you create a Minimal API project?

.NET

    dotnet new web -n MinimalApiStarter 
    cd MinimalApiStarter

Checkpoint: dotnet run starts the server without errors.

2) How do you enable OpenAPI document generation?

.NET

    Add the official OpenAPI package: 
    dotnet add package Microsoft.AspNetCore.OpenApi

Checkpoint: Package install succeeds.

3) How do you create a service layer so handlers don’t become “mini controllers”?

.NET

    Create Services/ProductService.cs: 
    namespace MinimalApiStarter.Services;
    public record ProductDto(int Id, string Name, decimal Price);
    public record CreateProductRequest(string Name, decimal Price);
    public interface IProductService
    {
        Task GetAsync(int id, CancellationToken ct);
        Task CreateAsync(CreateProductRequest request, CancellationToken ct);
    }
    public sealed class ProductService : IProductService
    {
        public Task GetAsync(int id, CancellationToken ct)
            => Task.FromResult(id == 404 ? null : new ProductDto(id, "Demo", 10m));
        public Task CreateAsync(CreateProductRequest request, CancellationToken ct)
            => Task.FromResult(new ProductDto(123, request.Name, request.Price));
    }

Checkpoint: No ASP.NET-specific types appear in the service.

4) How do you centralize validation using an endpoint filter?

.NET

    Create Infrastructure/ValidateCreateProductFilter.cs:
    using Microsoft.AspNetCore.Http.HttpResults;
    using MinimalApiStarter.Services;

    namespace MinimalApiStarter.Infrastructure;

    public sealed class ValidateCreateProductFilter : IEndpointFilter
    {
       public async ValueTask InvokeAsync(
          EndpointFilterInvocationContext context,
          EndpointFilterDelegate next)
       {
           var request = context.Arguments.OfType().FirstOrDefault();

           if (request is null)
               return TypedResults.BadRequest(new { error = "Request body is required." });

           var errors = new Dictionary();

           if (string.IsNullOrWhiteSpace(request.Name))
              errors["name"] = new[] { "Name is required." };

           if (request.Price < 0)
              errors["price"] = new[] { "Price must be >= 0." };

           if (errors.Count > 0)
               return TypedResults.ValidationProblem(errors);

           return await next(context);
       }
    }

Checkpoint: Validation rules are written once and reused, handlers stay clean.

5) How do you define endpoints as a feature module with a route group?

.NET

    Create Endpoints/ProductsEndpoints.cs: 
    using Microsoft.AspNetCore.Http.HttpResults;
    using MinimalApiStarter.Infrastructure;
    using MinimalApiStarter.Services;
    namespace MinimalApiStarter.Endpoints;
    public static class ProductsEndpoints
    {
        public static RouteGroupBuilder MapProductsEndpoints(this IEndpointRouteBuilder app)
        {
            var group = app.MapGroup("/api/products")
                .WithTags("Products")
                .RequireAuthorization("api");
            group.MapGet("/{id:int}", async Task<Results<Ok<ProductDto>, NotFound>> (
                int id,
                IProductService service,
                CancellationToken ct) =>
            {
                var product = await service.GetAsync(id, ct);
                return product is null ? TypedResults.NotFound() : TypedResults.Ok(product);
            })
            .Produces<ProductDto>(StatusCodes.Status200OK)
            .Produces(StatusCodes.Status404NotFound)
            .WithOpenApi();
            group.MapPost("/", async Task<Created<ProductDto>> (
                CreateProductRequest request,
                IProductService service,
                CancellationToken ct) =>
            {
                var created = await service.CreateAsync(request, ct);
                return TypedResults.Created($"/api/products/{created.Id}", created);
            })
            .AddEndpointFilter<ValidateCreateProductFilter>()
            .Produces<ProductDto>(StatusCodes.Status201Created)
            .ProducesValidationProblem()
            .WithOpenApi();
            return group;
        }
    }

Checkpoint: No endpoints are mapped inside Program.cs.

6) How do you wire auth, ProblemDetails, OpenAPI, and modules in Program.cs?

.NET

    Replace Program.cs with: 
    using MinimalApiStarter.Endpoints;
    using MinimalApiStarter.Services;
    var builder = WebApplication.CreateBuilder(args);
    // OpenAPI document generation
    builder.Services.AddOpenApi();
    // Problem Details support (standardized error shape)
    builder.Services.AddProblemDetails();
    // Demo authorization policy (replace with real auth in production)
    builder.Services.AddAuthorization(options =>
    {
        options.AddPolicy("api", policy => policy.RequireAssertion(_ => true));
    });
    builder.Services.AddScoped();
    var app = builder.Build();
    // Centralized exception handler (works well with ProblemDetails)
    app.UseExceptionHandler();
    app.UseAuthorization();
    // Expose OpenAPI JSON endpoint
    app.MapOpenApi();
    // Map feature modules
    app.MapProductsEndpoints();
    app.Run();
    // For integration tests (WebApplicationFactory)
    public partial class Program { }

Checkpoint: dotnet run compiles and starts successfully.

How do you test and verify the API?

How do you run the API locally?

.NET

    dotnet run

How do you verify GET returns a product?

cURL

    curl -i http://localhost:5000/api/products/1

Expected:

200 OK
JSON like: {“id”:1,”name”:”Demo”,”price”:10}

Checkpoint: You get a 200 with JSON for /1.

How do you verify GET returns 404 for missing

cURL

    curl -i http://localhost:5000/api/products/404

Expected:

404 Not Found

Checkpoint: /404 returns 404.

How do you verify validation runs via the endpoint filter?

cURL

    curl -i -X POST http://localhost:5000/api/products \ 
      -H "Content-Type: application/json" \ 
      -d "{\"name\":\"\",\"price\":-1}"

Expected:

400 Bad Request
A validation payload (from ValidationProblem)

Checkpoint: Validation fails before the handler runs.

How do you verify OpenAPI is being generated?

Fetch the OpenAPI JSON exposed by MapOpenApi() (path depends on your ASP.NET Core version/config). Confirm you see a JSON document containing /api/products/{id} and /api/products.

Checkpoint: OpenAPI JSON includes your endpoints and response metadata.

How do you add an integration test to prove endpoint wiring works?

1) How do you add a test project?

.NET

    dotnet new xunit -n MinimalApiStarter.Tests 
    dotnet add MinimalApiStarter.Tests reference MinimalApiStarter 
    dotnet add MinimalApiStarter.Tests package Microsoft.AspNetCore.Mvc.Testing

2) How do you write a minimal integration test?

.NET

    Create MinimalApiStarter.Tests/ProductsApiTests.cs: 
    using System.Net; 
    using Microsoft.AspNetCore.Mvc.Testing; 
    using Xunit; 

    public class ProductsApiTests : IClassFixture> 
    { 
        private readonly HttpClient _client; 

        public ProductsApiTests(WebApplicationFactory factory) 
        { 
            _client = factory.CreateClient(); 
        } 

        [Fact] 
        public async Task Get_Product_ReturnsOk() 
        { 
            var resp = await _client.GetAsync("/api/products/1"); 
            Assert.Equal(HttpStatusCode.OK, resp.StatusCode); 
        } 

        [Fact] 
        public async Task Get_MissingProduct_ReturnsNotFound() 
        { 
            var resp = await _client.GetAsync("/api/products/404"); 
            Assert.Equal(HttpStatusCode.NotFound, resp.StatusCode); 
        } 
    }

Run:

.NET

    dotnet test

Checkpoint: Tests pass and confirm routing + module mapping works.

What are the most common production mistakes with Minimal APIs and how do you fix them?

1) Why did my Minimal API turn into a “giant Program.cs”?

Cause: You mapped endpoints directly in Program.cs as the project grew.

Fix: Move each feature into Endpoints/_Endpoints.cs with Map_Endpoints().

2) Why are my endpoints inconsistent (validation, errors, logging)?

Cause: Each handler does its own checks and error shapes.

Fix: Use endpoint filters for validation, and standardize error responses using Problem Details.

3) Why does RequireAuthorization(“api”) throw “policy not found”?

Cause: Policy wasn’t registered or name mismatch.

Fix: Ensure AddAuthorization(options => options.AddPolicy(“api”, …)) matches exactly.

4) Why does my POST look like the handler runs even with bad input?

Cause: Validation is in-handler, or the filter wasn’t applied.

Fix: Confirm .AddEndpointFilter() is on the endpoint or group.

5) Why is my OpenAPI endpoint returning 404?

Cause: OpenAPI services weren’t added or endpoint wasn’t mapped.

Fix: Confirm builder.Services.AddOpenApi() and app.MapOpenApi() are both present.

What did you achieve, and what should you do next?

You now have a Minimal API starter that’s intentionally “production-shaped”:

Route groups + feature modules keep code discoverable
Endpoint-filter validation keeps handlers thin
ProblemDetails gives predictable error responses
OpenAPI generation keeps API docs accurate
Integration tests prove wiring won’t regress

Next step: Replace the demo authorization policy with real authentication (JWT/OAuth), then align your API security checklist with OWASP’s API Security Top 10.

Start today and unlock all features of BoldSign.

Need assistance? Request a demo or visit our Support Portal for quick help.

Bring fast, secure eSignatures to your Minimal APIs with BoldSign’s developer-friendly API.

Try BoldSign API Free

Related blogs

Note: This blog was originally published at boldsign.com

Prevent “I Didn’t Sign This” Claims with ID Verification Methods & Audit Trails

Vijay Amalan — Tue, 28 Apr 2026 05:29:15 +0000

“I didn’t sign this” claims, also known as repudiation claims, pose a serious risk in electronic signature workflows. They can delay deals, trigger costly disputes, damage trust, and create compliance issues, especially for legal paperwork, high‑value contracts, financial documents, and HR agreements. BoldSign effectively minimizes these risks by combining advanced signer identity verification with comprehensive, tamper-evident audit trails.

This layered approach delivers undeniable proof of who signed, when they signed, their intent, and that the document remained unchanged, ensuring strong non-repudiation and legally defensible agreements.

What are repudiation claims

Repudiation claims happen when a signer denies signing a document or claims the signature was unauthorized, forged, or completed through a compromised account. In electronic signature workflows, these disputes can delay agreements, create legal challenges, and increase operational risk. They are especially common in low-security workflows that rely only on email access without stronger identity checks.

What is the risk of repudiation in electronic signatures

Repudiation occurs when a signer denies signing a document, claiming it was forged, unauthorized, or completed through a compromised account. This is more common in basic email-only workflows with minimal identity checks. High-value or regulated agreements are especially vulnerable, as disputes can invalidate contracts, lead to legal challenges, and cause financial or operational harm.

For an electronic signature to be enforceable and provide non-repudiation, it must prove three key elements:

Signer intent – Clear evidence they meant to sign.
Signer identity – Reasonable (or strong) confirmation of who they are.
Document integrity – Proof the document wasn’t altered after signing.

BoldSign exceeds these requirements through layered security features, making repudiation claims extremely difficult to sustain.

BoldSign’s advanced identity verification methods

BoldSign offers flexible, multi-layered authentication options to confirm the signer is the authorized person before they access or complete the document. You can apply these selectively per signer (including in multi-party workflows) or standardize them via templates.

Key methods include:

Email OTP – A one-time password sent to the signer’s email; they must enter it to proceed, confirming email ownership.
SMS OTP – A one‑time code sent to the signer’s phone by text message.
Access Code – A custom PIN you create and share securely through a separate channel; the signer enters it for access.
Government ID Verification with Biometric Selfie – For higher-risk documents, require:
- Upload of a government-issued ID (e.g., passport, driver’s license, national ID card).
- A live biometric selfie.
- Advanced matching (powered by technology like Stripe Identity) compares the selfie to the ID photo, with configurable strictness levels (strict, moderate, lenient) and options like live document capture to prevent photos or photocopies.

Identity Verification

These controls, especially government ID with a selfie, tie the signing process to real‑world identity and significantly reduce impersonation and unauthorized access risks.

What does an audit trail prove

Every BoldSign document includes a detailed, tamper-evident audit trail that logs the entire signing process. This creates a consistent, court-admissible record supporting non-repudiation.

The audit trail typically captures:

Precise timestamps for events (sent, viewed, authenticated, signed, completed).
IP addresses and device details.
Authentication activity, including methods used such as OTP, access code, and ID verification.
Signer actions and consent to electronic disclosures.
Document integrity verification, using cryptographic hashes to confirm that no alterations were made after signing.
Sender and recipient information, including names and email addresses.

After completion, download the audit trail as a branded PDF (separately or combined with the signed document). It is digitally signed to prevent tampering, ensuring reliability for reviews, audits, or disputes.

How do ID verification and audit trails work together

This combination forms a powerful, multi-layered defense:

Identity is verified upfront – Blocking unauthorized users before access.
Every key action is logged – With timestamps, IP/device data, and verification outcomes.
Integrity is preserved – Through hashes and tamper-evident records.

Together, they generate a complete evidence package: Proven identity + documented intent + unaltered document. This makes repudiation claims unsustainable and supports compliance with standards like ESIGN Act, UETA, and eIDAS.

Key business benefits

Here’s how these features translate into real business advantages:

Stronger legal defensibility – Meets or exceeds global e-signature laws with verifiable non-repudiation.
Fewer disputes and faster resolution – Clear and reliable evidence minimizes challenges and speeds up issue handling.
Enhanced trust – Signers, partners, legal teams, and stakeholders gain confidence from robust security.
Flexible security – Apply stricter verification only where needed (e.g., high-value documents), balancing protection with efficiency.
Operational efficiency – Avoids costly delays from repudiation claims and streamlines workflows.

Conclusion

“I didn’t sign this” claims don’t have to derail your agreements. BoldSign’s robust identity verification paired with detailed, tamper-evident audit trails provides strong proof of identity, intent, and document integrity, virtually eliminating repudiation risks.

Secure your high-value or regulated workflows with confidence. Try BoldSign free and explore powerful audit logging, automated workflows, and secure signing.

Have questions? Our team is here, schedule a demo and get expert support.

Related blogs

Note: This blog was originally published at boldsign.com

Free Email QR Code Generator for Ready‑to‑Use Email Drafts

Vijay Amalan — Mon, 27 Apr 2026 05:34:12 +0000

We are excited to introduce the free BoldSign Email QR Code Generator, a simple and secure tool that helps anyone share a complete email template, including email address, subject, and message, with a quick scan. Whether you’re a freelancer adding contact details to business cards, a professional sharing support information on brochures, or a small business placing QR codes on packaging, this tool makes communication effortless. There is no software to install, no account required, and no cost. Everything runs inside your browser, keeping your information private and helping you connect faster.

Why choose the free BoldSign Email QR Code Generator

Our email QR code generator is built for convenience, privacy, and professional results. It works entirely inside your browser, so your email information is never stored. It is perfect for professionals, creators, and businesses who want a quick way for people to reach their inbox.

Here are the main reasons for choosing our tool:

Completely free: No sign up, no fees, and no restrictions. Create email QR codes online for free.
Privacy first: All processing happens on your device. Your information is never saved or shared.
Professional look: Generate clean and polished QR codes ideal for business cards, posters, menus, flyers, resumes, and printed materials.
Works everywhere: Create email QR codes from your phone, tablet, or computer without installing anything.
Fast and simple: Add your email address, subject, or message and generate a QR code in seconds.

Key features of the free Email QR Code Generator

Whether you’re sharing a support email or a personal contact address, these features make BoldSign your go‑to solution:

Custom email details: Add your email address along with a subject and an optional predefined message so people can contact you instantly with the right context.
High quality downloads: Download clear and print ready QR codes perfect for physical or digital use.
Unlimited creation: Generate as many email QR codes as you need. There are no limits and no watermarks.
Simple customization: Adjust the appearance of the QR code if supported on the page, so it matches your brand or design.
Beginner friendly: No technical knowledge is needed. Enter your details and download them immediately.

How to create an email QR code in three simple steps

Getting started takes only a few clicks. Follow these three steps to create your first email QR code:

Open the tool: Go to the free BoldSign Email QR Code Generator.
Enter your information: Type your email address, subject line, and optional message. Customize the appearance if needed.
Download your email QR Code: Save your QR code as PNG, SVG, or JPEG, and display it anywhere so guests can scan and connect instantly.

Start sharing your email smarter today

The free BoldSign Email QR Code Generator makes sharing your email address fast, simple, and accessible to everyone. Whether you are a freelancer, business owner, job seeker, or student, this tool helps people reach you instantly with a quick scan. There is no cost, no setup, and no technical skills required. Create your QR code in minutes and make communication easier than ever.

Ready to simplify your document workflows? Sign up for a free 30-day trial or connect with our support team for a personalized demo.

Related blogs

Note: This blog was originally published at boldsign.com

BoldSign Edit Document API: Update Signers, Fields, and Files Without Restarting

Vijay Amalan — Tue, 21 Apr 2026 03:44:23 +0000

Updating documents mid-workflow usually means recreating them, reassigning fields, and disrupting signers. The BoldSign Edit Document API lets you update signer details, fields, metadata, and even files without restarting the signing process.

This guide is for developers, product teams, and automation engineers working with BoldSign. It explains what the Edit Document API can update, how it works, when to use it, and how to perform safe updates with clear examples.

What problem this solves

Most eSignature systems treat documents as nearly immutable once created. Any mistakes, such as incorrect signer emails, missing signature fields, outdated clauses, or wrong files, often require:

Recreating the document
Reapplying all fields manually
Re-inviting all signers
Losing audit continuity

The BoldSign Edit Document API eliminates all of these problems.

It helps you:

Correct signer details without interrupting signing
Add or modify fields dynamically
Replace or remove files without re uploading a document package
Update instructions, messages, or labels instantly
Keep workflows running even when your business logic changes

How does the BoldSign edit document API work?

The API uses a flexible update model where you send only the changes you need. It supports two modes of processing based on whether the request includes files.

How does the completed (synchronous) mode work?

If your request does not include files, edits are applied immediately.

Useful for:

Metadata updates
Signer property updates
Adding or removing form fields
Label changes
Reminder setting modifications

You receive a response with: “status”: “Completed”

How does the queued (asynchronous) mode work?

If your request includes files, BoldSign processes the update in the background.

You receive: “status”: “Queued”

After processing finishes, you receive webhook events:

Edited → change successful
EditFailed → change unsuccessful, includes failure reason

This makes file replacement safe and traceable.

Why you need document properties before editing?

To update files, signers, or form fields, you must have their corresponding IDs:

fileId
ignerId
formFieldId

These IDs are retrieved from the Document Properties API, which returns the complete document structure, including all editable resources and their IDs.

This is mandatory for safe, targeted updates.

How do partial updates differ from nested updates?

What do partial updates change?

Partial updates allow you to send only the fields you want modified, BoldSign leaves the rest untouched.

Perfect for top level updates such as:

Message
Labels
Reminder settings

How do nested updates work for files, signers & fields?

Nested resources require:

EditAction = Add | Update | Remove
The resource’s ID (fileId, signerId, formFieldId)

For example:

Updating a signer requires signerId
Removing a form field requires formFieldId

This prevents overwriting the entire signer or field structure.

What you’ll need before calling the edit document API?

Make sure you have the following ready:

A BoldSign account (sandbox or production).
An API key (or OAuth2 access token) to call BoldSign APIs over HTTPS.
A REST client such as cURL, Postman, or your preferred HTTP library.
documentId – The ID of the document you want to edit.
Property IDs – File IDs, signer IDs, and form field IDs (retrieved via /v1/document/properties).
Basic API Tooling – Ability to make HTTP calls (e.g., cURL, Postman, or any BoldSign SDK).

Authentication headers

Use one of the following:

API Key: X-API-KEY:
OAuth2: Authorization: Bearer

How do you update signers and metadata without editing files?

Because no files are included, this triggers synchronous mode (Completed).

Below is an example code snippet

cURL

    curl -X PUT 'https://api.boldsign.com/v1-beta/document/edit?documentId=YOUR-DOCUMENT-ID' \
    -H 'Content-Type: application/json' \
    -H 'X-API-KEY: {API-KEY}' \
    -d '{
        "Message": "Please sign this document.",
        "Signers": [
            {
                "EditAction": "Update",
                "Id": "YOUR-SIGNER-ID",
                "AuthenticationType": "EmailOTP",
                "FormFields": [
                    {
                        "EditAction": "Add",
                        "FieldType": "TextBox",
                        "Bounds": {
                            "X": 100,
                            "Y": 100,
                            "Width": 100,
                            "Height": 20
                        },
                        "IsRequired": false,
                        "PageNumber": 1
                    }
                ]
            },
            {
                "EditAction": "Add",
                "Name": "Signer",
                "EmailAddress": "signer@gmail.com",
                "AuthenticationType": "AccessCode",
                "AuthenticationCode": "1234",
                "FormFields": [
                    {
                        "EditAction": "Add",
                        "FieldType": "Signature",
                        "Bounds": {
                            "X": 150,
                            "Y": 150,
                            "Width": 200,
                            "Height": 30
                        },
                        "IsRequired": true,
                        "PageNumber": 1
                    }
                ]
            }
        ],
        "Labels": ["Label1", "Label2"],
        "ReminderSettings": {
            "EnableAutoReminder": true,
            "ReminderDays": 2,
            "ReminderCount": 4
        }
    }'

    var apiClient = new ApiClient("https://api.boldsign.com", "YOUR_API_KEY");
    var documentClient = new DocumentClient(apiClient);
    // --- Form fields for existing signer ---
    var textField = new EditFormField()
    {
        EditAction = EditAction.Add,
        Type = FieldType.TextBox,
        IsRequired = false,
        Bounds = new Rectangle()
        {
            X = 100,
            Y = 100,
            Width = 100,
            Height = 20,
        },
        PageNumber = 1,
    };
    var signerToUpdate = new EditDocumentSigner()
    {
        EditAction = EditAction.Update,
        Id = "YOUR-SIGNER-ID",
        AuthenticationType = AuthenticationType.EmailOTP,
        FormFields = new List<EditFormField>()
        {
            textField
        }
    };
    // --- Form fields for new signer ---
    var signatureField = new EditFormField()
    {
        EditAction = EditAction.Add,
        Type = FieldType.Signature,
        IsRequired = false,
        Bounds = new Rectangle()
        {
            X = 150,
            Y = 150,
            Width = 200,
            Height = 30,
        },
        PageNumber = 1,
    };
    var signerToAdd = new EditDocumentSigner()
    {
        EditAction = EditAction.Add,
        Name = "Signer",
        EmailAddress = "signer@gmail.com",
        AuthenticationType = AuthenticationType.AccessCode,
        AuthenticationCode = "1234",
        FormFields = new List<EditFormField>()
        {
            signatureField
        }
    };
    // --- Signers collection ---
    var documentSigners = new List<EditDocumentSigner>()
    {
        signerToUpdate,
        signerToAdd
    };
    // --- Labels ---
    var labels = new List<string>()
    {
        "Label1",
        "Label2"
    };
    // --- Reminder settings ---
    var reminderSettings = new ReminderSettings()
    {
        EnableAutoReminder = true,
        ReminderCount = 4,
        ReminderDays = 2,
    };
    // --- Final request ---
    var editDocumentRequest = new EditDocumentRequest()
    {
        DocumentId = "YOUR-DOCUMENT-ID",
        Message = "Please sign this document.",
        Signers = documentSigners,
        Labels = labels,
        ReminderSettings = reminderSettings
    };
    var documentEdited = documentClient.EditDocument(editDocumentRequest);

Python

    import boldsign
    configuration = boldsign.Configuration(api_key="YOUR_API_KEY")
    with boldsign.ApiClient(configuration) as api_client:
        document_api = boldsign.DocumentApi(api_client)
        document_id = "YOUR-DOCUMENT-ID"
        signer1 = boldsign.EditDocumentSigner(
            edit_action="Update",
            id="YOUR-SIGNER-ID",
            authentication_type="EmailOTP",
            form_fields=[
                boldsign.EditFormField(
                    edit_action="Add",
                    fieldType="TextBox",
                    is_required=False,
                    bounds=boldsign.Rectangle(x=100, y=100, width=100, height=20),
                    page_number=1
                )
            ]
        )
        signer2 = boldsign.EditDocumentSigner(
            edit_action="Add",
            name="Signer22",
            email_address="signer@gmail.com",
            authentication_type="AccessCode",
            authentication_code="1234",
            form_fields=[
                boldsign.EditFormField(
                    edit_action="Add",
                    type="Signature",
                    is_required=False,
                    bounds=boldsign.Rectangle(x=150, y=150, width=200, height=30),
                    page_number=1
                )
            ]
        )
        edit_request = boldsign.EditDocumentRequest(
            message="Please sign this document.",
            signers=[signer1, signer2],
            labels=["Label1", "Label2"],
            reminder_settings=boldsign.ReminderSettings(
                enable_auto_reminder=True,
                reminder_count=4,
                reminder_days=2
            )
        )
        response = document_api.edit_document(document_id, edit_request)

PHP

    <?php require_once "vendor/autoload.php";
    use BoldSign\Configuration;
    use BoldSign\Api\DocumentApi;
    use BoldSign\Model\EditDocumentRequest;
    use BoldSign\Model\EditDocumentSigner;
    use BoldSign\Model\EditFormField;
    use BoldSign\Model\Rectangle;
    use BoldSign\Model\ReminderSettings;
    use BoldSign\Model\EditDocumentFile;
    $config = new Configuration();
    $config->setApiKey('YOUR_API_KEY');
    $apiInstance = new DocumentApi($config);
    $document_id = "YOUR-DOCUMENT-ID";
    $formField2 = new EditFormField();
    $formField2->setEditAction("Add");
    $formField2->setFieldType("TextBox");
    $formField2->setIsRequired(false);
    $formField2->setBounds(new Rectangle([100, 100, 100, 20]));
    $formField2->setPageNumber(1);
    $signer1 = new EditDocumentSigner();
    $signer1->setEditAction("Update");
    $signer1->setId("YOUR-SIGNER-ID");
    $signer1->setAuthenticationType("EmailOTP");
    $signer1->setFormFields([$formField2]);
    $formField3 = new EditFormField();
    $formField3->setEditAction("Add");
    $formField3->setFieldType("Signature");
    $formField3->setBounds(new Rectangle([100, 100, 100, 70]));
    $formField3->setPageNumber(1);
    $signer2 = new EditDocumentSigner();
    $signer2->setEditAction("Add");
    $signer2->setName("Signer");
    $signer2->setEmailAddress("signer@gmail.com");
    $signer2->setAuthenticationType("AccessCode");
    $signer2->setAuthenticationCode("1234");
    $signer2->setFormFields([$formField3]);
    $reminderSettings = new ReminderSettings();
    $reminderSettings->setEnableAutoReminder(true);
    $reminderSettings->setReminderCount(4);
    $reminderSettings->setReminderDays(2);
    $edit_document_request = new EditDocumentRequest();
    $edit_document_request->setMessage('Please sign this document.');
    $edit_document_request->setSigners([$signer1, $signer2]);
    $edit_document_request->setLabels(["Label1", "Label2"]);
    $edit_document_request->setReminderSettings($reminderSettings);
    $edit_document_response = $apiInstance->editDocument($document_id, $edit_document_request);

Java

    ApiClient apiClient = Configuration.getDefaultApiClient();
            apiClient.setApiKey("YOUR_API_KEY");
            DocumentApi documentApi = new DocumentApi(apiClient);
            Rectangle bounds = new Rectangle();
            bounds.setX(50f);
            bounds.setY(100f);
            bounds.setWidth(100f);
            bounds.setHeight(60f);
            EditFormField formField = new EditFormField();
            formField.setEditAction(EditFormField.EditActionEnum.ADD);
            formField.setFieldType(EditFormField.FieldTypeEnum.SIGNATURE);
            formField.setPageNumber(1);
            formField.setBounds(bounds);
            EditDocumentSigner signers = new EditDocumentSigner();
            signers.setEmailAddress("signer@gmail.com");
            signers.setName("signername");
            signers.setFormFields(Arrays.asList(formField));
            signers.setEditAction(EditDocumentSigner.EditActionEnum.ADD);
            EditDocumentRequest editDocumentJsonRequest = new EditDocumentRequest();
            editDocumentJsonRequest.setSigners(Arrays.asList(signers));
            editDocumentJsonRequest.setMessage("Updated documents");
            String documentId = "YOUR-DOCUMENT-ID";
            documentApi.editDocument(documentId, editDocumentJsonRequest);

Node js

    import {
        DocumentApi,
        EditDocumentFile,
        EditDocumentRequest,
        EditDocumentSigner,
        EditFormField,
        Rectangle,
        ReminderSettings
    } from "boldsign";
    import * as fs from 'fs';
    const documentApi = new DocumentApi();
    documentApi.setApiKey("YOUR_API_KEY");
    const documentId = "YOUR-DOCUMENT-ID";
    const bounds1 = new Rectangle();
    bounds1.x = 100;
    bounds1.y = 100;
    bounds1.width = 100;
    bounds1.height = 20;
    const formField1 = new EditFormField();
    formField1.editAction = EditFormField.EditActionEnum.Add;
    formField1.fieldType = EditFormField.FieldTypeEnum.TextBox;
    formField1.isRequired = false;
    formField1.bounds = bounds1;
    formField1.pageNumber = 1;
    const signer1 = new EditDocumentSigner();
    signer1.editAction = EditDocumentSigner.EditActionEnum.Update;
    signer1.id = "YOUR-SIGNER-ID";
    signer1.authenticationType = EditDocumentSigner.AuthenticationTypeEnum.EmailOtp;
    signer1.formFields = [formField1];
    const bounds2 = new Rectangle();
    bounds2.x = 150;
    bounds2.y = 150;
    bounds2.width = 200;
    bounds2.height = 30;
    const formField3 = new EditFormField();
    formField3.editAction = EditFormField.EditActionEnum.Add;
    formField3.fieldType = EditFormField.FieldTypeEnum.Signature;
    formField3.isRequired = false;
    formField3.bounds = bounds2;
    formField3.pageNumber = 1;
    const signer2 = new EditDocumentSigner();
    signer2.editAction = EditDocumentSigner.EditActionEnum.Add;
    signer2.name = "Signer";
    signer2.emailAddress = "signer@gmail.com";
    signer2.authenticationType =EditDocumentSigner.AuthenticationTypeEnum.AccessCode;
    signer2.authenticationCode = "1234";
    signer2.formFields = [formField3];
    const reminderSettings = new ReminderSettings();
    reminderSettings.enableAutoReminder = true;
    reminderSettings.reminderCount = 4;
    reminderSettings.reminderDays = 2;
    const editDocumentRequest = new EditDocumentRequest();
    editDocumentRequest.message = "Please review and sign the attached document.";
    editDocumentRequest.signers = [signer1, signer2];
    editDocumentRequest.labels = ["Label1", "Label2"];
    editDocumentRequest.reminderSettings = reminderSettings;
    const editDocumentResponse = await documentApi.editDocument(documentId, editDocumentRequest);

How do you edit files using the edit document API?

Files in the request immediately enable asynchronous processing(Queued).

Remove a file → all form fields linked to that file are automatically removed. (Because the file no longer exists, its fields cannot remain.)
Add a file → the new file is added as the last file in the document. (It appears at the end of the file list; fetch Document Properties to get its new fileId.)
Replace a file → form fields on pages that no longer exist are deleted. (Example: Old file had 5 pages, new file has 3 → fields on pages 4–5 are removed.

Below is an example code snippet

cURL

    curl -X PUT 'https://api.boldsign.com/v1-beta/document/edit?documentId=YOUR-DOCUMENT-ID' \
    -H 'Content-Type: application/json' \
    -H 'X-API-KEY: {API-KEY}' \
    -d '{
          "files": [
        {
          "editAction": "Add",
          "fileUrl": "YOUR_FILE_URL"
        }
      ]
    }'

    var apiClient = new ApiClient("https://api.boldsign.com", "YOUR_API_KEY");
    var documentClient = new DocumentClient(apiClient);
    // File to edit
    var editDocumentFile = new EditDocumentFile()
    {
        EditAction = EditAction.Add,
        FileUrl = new Uri("YOUR_FILE_URL")
    };
    var filesToEdit = new List<EditDocumentFile>()
    {
        editDocumentFile
    };
    // Final request
    var editDocumentRequest = new EditDocumentRequest()
    {
        DocumentId = "YOUR-DOCUMENT-ID",
        Files = filesToEdit
    };
    var documentEdited = documentClient.EditDocument(editDocumentRequest);

Python

    import boldsign
    configuration = boldsign.Configuration(api_key="YOUR_API_KEY")
    with boldsign.ApiClient(configuration) as api_client:
        document_api = boldsign.DocumentApi(api_client)
        document_id = "YOUR-DOCUMENT-ID"
        document_file = boldsign.EditDocumentFile(
            edit_action="Add",
            file='YOUR_FILE_PATH'
        )
        edit_request = boldsign.EditDocumentRequest(
            files=[document_file]
        )
        response = document_api.edit_document(document_id, edit_request)

PHP

    <?php require_once "vendor/autoload.php";
    use BoldSign\Configuration;
    use BoldSign\Api\DocumentApi;
    use BoldSign\Model\EditDocumentRequest;
    use BoldSign\Model\EditDocumentFile;
    $config = new Configuration();
    $config->setApiKey('YOUR_API_KEY');
    $apiInstance = new DocumentApi($config);
    $document_id = "YOUR-DOCUMENT-ID";
    $edit_document_request = new EditDocumentRequest();
    $document1 = new EditDocumentFile();
    $document1->setFileUrl("YOUR_FILE_URL");
    $document1->setEditAction('Add');
    $edit_document_request->setFiles([$document1]);
    $edit_document_response = $apiInstance->editDocument($document_id, $edit_document_request);

Java

    ApiClient apiClient = Configuration.getDefaultApiClient();
            apiClient.setApiKey("YOUR_API_KEY");
            DocumentApi documentApi = new DocumentApi(apiClient);
            EditDocumentFile document = new EditDocumentFile();
            document.setEditAction(EditDocumentFile.EditActionEnum.ADD);
            document.setFileUrl( new URI( "YOUR_FILE_URL"));
            EditDocumentRequest editDocumentJsonRequest = new EditDocumentRequest();
            editDocumentJsonRequest.setFiles(Arrays.asList(document));
            String documentId = "YOUR-DOCUMENT-ID";
            documentApi.editDocument(documentId, editDocumentJsonRequest);

Node js

    import {
        DocumentApi,
        EditDocumentFile,
        EditDocumentRequest
    } from "boldsign";
    import * as fs from 'fs';
    const documentApi = new DocumentApi();
    documentApi.setApiKey("YOUR_API_KEY");
    const documentId = "YOUR-DOCUMENT-ID";
    const documentfile = new EditDocumentFile();
    documentfile.file = fs.createReadStream("YOUR_FILE_PATH");
    documentfile.editAction = EditDocumentFile.EditActionEnum.Add;
    const editDocumentRequest = new EditDocumentRequest();
    editDocumentRequest.files = [documentfile];
    const editDocumentResponse = await documentApi.editDocument(documentId, editDocumentRequest);

How do you edit single field to the same signer using the edit document API?

You can update just one property of a signer without resending all their details.

When you update a signer:

Only the specific field you send is changed.
If you remove a signer, all form fields linked to that signer are automatically removed.

How do you update only the IsRequired property on an existing form field?

cURL

    curl -X PUT 'https://api.boldsign.com/v1-beta/document/edit?documentId=YOUR-DOCUMENT-ID' \
    -H 'Content-Type: application/json' \
    -H 'X-API-KEY: {API-KEY}' \
    -d '{
        "Signers": [
            {
                "EditAction": "Update",
                "Id": "YOUR-SIGNER-ID",
                "FormFields": [
                    {
                        "EditAction": "Update",
                        "Id": "YOUR-FIELD-ID",
                        "IsRequired": false
                    }
                ]
            }
        ]
    }'

    var apiClient = new ApiClient("https://api.boldsign.com", "YOUR_API_KEY");
    var documentClient = new DocumentClient(apiClient);
    var signerToUpdate = new EditDocumentSigner()
    {
        EditAction = EditAction.Update,
        Id = "YOUR-SIGNER-ID",
        AuthenticationCode = "1234"
    };
    // --- Signers collection ---
    var documentSigners = new List<EditDocumentSigner>()
    {
        signerToUpdate
    };
    // --- Final request ---
    var editDocumentRequest = new EditDocumentRequest()
    {
        DocumentId = "YOUR-DOCUMENT-ID",
        Signers = documentSigners
    };
    var documentEdited = documentClient.EditDocument(editDocumentRequest);

Python

    import boldsign
    configuration = boldsign.Configuration(api_key="YOUR_API_KEY")
    with boldsign.ApiClient(configuration) as api_client:
        document_api = boldsign.DocumentApi(api_client)
        document_id = "YOUR-DOCUMENT-ID"
        signer1 = boldsign.EditDocumentSigner(
            edit_action="Update",
            id="YOUR-SIGNER-ID",
            authentication_code="1234"
        )
        edit_request = boldsign.EditDocumentRequest(
            signers=[signer1],
        )
        response = document_api.edit_document(document_id, edit_request)

PHP

    <?php require_once "vendor/autoload.php";
    use BoldSign\Configuration;
    use BoldSign\Api\DocumentApi;
    use BoldSign\Model\EditDocumentRequest;
    use BoldSign\Model\EditDocumentSigner;
    $config = new Configuration();
    $config->setApiKey('YOUR_API_KEY');
    $apiInstance = new DocumentApi($config);
    $document_id = "YOUR-DOCUMENT-ID";
    $signer1 = new EditDocumentSigner();
    $signer1->setEditAction("Update");
    $signer1->setId("YOUR-SIGNER-ID");
    $signer1->setAuthenticationCode("1234");
    $edit_document_request = new EditDocumentRequest();
    $edit_document_request->setSigners([$signer1]);
    $edit_document_response = $apiInstance->editDocument($document_id, $edit_document_request);

Java

    ApiClient apiClient = Configuration.getDefaultApiClient();
            apiClient.setApiKey("YOUR_API_KEY");
            DocumentApi documentApi = new DocumentApi(apiClient);
            EditDocumentSigner signers = new EditDocumentSigner();
            signers.setAuthenticationCode("1234");
            signers.setId("YOUR-SIGNER-ID");
            signers.setEditAction(EditDocumentSigner.EditActionEnum.UPDATE);
            EditDocumentRequest editDocumentJsonRequest = new EditDocumentRequest();
            editDocumentJsonRequest.setSigners(Arrays.asList(signers));
            String documentId = "YOUR-DOCUMENT-ID";
            documentApi.editDocument(documentId, editDocumentJsonRequest);

Node js

    import {
        DocumentApi,
        EditDocumentRequest,
        EditDocumentSigner,
    } from "boldsign";
    import * as fs from 'fs';
    const documentApi = new DocumentApi();
    documentApi.setApiKey("YOUR_API_KEY");
    const documentId = "YOUR-DOCUMENT-ID";
    const signer1 = new EditDocumentSigner();
    signer1.editAction = EditDocumentSigner.EditActionEnum.Update;
    signer1.id = "YOUR-SIGNER-ID";
    signer1.authenticationCode = "1234";
    const editDocumentRequest = new EditDocumentRequest();
    editDocumentRequest.signers = [signer1];
    const editDocumentResponse = await documentApi.editDocument(documentId, editDocumentRequest);

You can update just one property of a form field, such as IsRequired, without modifying anything else in the signer or document.

What updates are restricted or not allowed when editing documents?

Some elements are immutable for security and compliance reasons.

Always immutable

You cannot change:

documentId
Completed signatures
Completed signer actions
Audit trail entries

Editable only in draft status

These can be changed only when the document is still a draft:

Title
BrandId
EnableSigningOrder
ScheduledSendTime

What if the document was created from a template?

When a document is created from a template, certain elements may already be locked based on the template’s settings:

Templates can restrict editing of files, signers, and form fields.
If the template disables editing, you cannot modify existing form fields, signers, or files using the Edit Document API.
These restrictions are defined during template creation and enforced to maintain template consistency and compliance.

What changes are restricted after any signer has already signed?

Once any signer has completed signing, the following changes are restricted:

Editing the details of a signer who has already signed is not allowed.
Removing a signer who has already signed is not allowed.
Uploading, replacing, or deleting document files is not allowed.
Form fields assigned to a signer who has completed signing cannot be changed.
Title, BrandId, and Signing Order cannot be edited after the document has been sent (they are editable only in draft).
Labels and hyperlinks cannot be edited or added because a signer has already completed signing.

How does the completion and error model work when you edit a document?

The Edited event confirms that your update was successfully applied. This is especially helpful for edits that were queued because they involved file changes. Available Webhook Events
The EditFailed event indicates the update could not be applied. It also includes error details, which you must fix before retrying the edit.
File-related edits run in the background and return Queued, so you won’t know the final result immediately. The Edited or EditFailed event is what confirms whether the update eventually succeeded or failed.

Best practices

What steps should you always follow?

Fetch → Edit → Verify
Always retrieve IDs using Document Properties
Only send the fields you want to modify

Why editing documents matters for API workflows?

Workflows change often; signer details, clauses, and form fields may need updates after a document is created.
Programmatic edits keep workflows running by allowing your backend to adjust documents without restarting the signing process.
Reduces human error because updates happen through predictable API calls rather than manual changes.
Supports scalable automation where documents can evolve dynamically based on business logic or real time data

Conclusion

The Edit Document API is most useful when your documents need updates after they’ve been created or sent, without disrupting the signing process. Whether you’re correcting signer details, adding new fields, updating instructions, or replacing files, the API lets you make precise changes safely and efficiently. By always fetching Document Properties first, using the right IDs, and understanding when edits run in Completed vs. Queued mode, you ensure that updates are applied smoothly and reliably.

In short, use the Edit Document API whenever your workflow requires mid-process adjustments, automation-friendly updates, or flexible document handling, all while keeping signers uninterrupted and your workflow running cleanly end‑to‑end.

If you’d like to explore more about BoldSign capabilities, sign up for a free BoldSign Sandbox account leave a comment, book a demo, or connect with our support team through the BoldSign support portal.

Related blogs

Note: This blog was originally published at boldsign.com

Track Approvals and Sign-Offs with a Construction Audit Trail

Vijay Amalan — Mon, 20 Apr 2026 05:29:50 +0000

Construction managers know the drill, a change of order needs three signatures, but the PDF on your laptop shows no clue who signed first or whether a subcontractor used an old version. That uncertainty slows projects, causes rework, and risks disputes. You need a clear audit trail that records who approved what (and when), so decisions are verifiable and projects keep moving. BoldSign can store that audit trail as part of each signed construction document without extra paperwork.

Why this topic matters

Construction projects depend on timely, accurate approvals. Missing or unclear approval records lead to:

Costly delays and rework.
Risk of non-compliance with contracts or regulations.
Disputes that require time-consuming evidence of gathering.

A robust audit trail reduces the risks and speeds of decision-making.

Simple real-life scenario

You’re a site engineer approving RFI responses on your phone between site checks. Later an owner asks – who approved change X and when. Without an audit trail, you guess. With the right audit trail, you pull a single document record showing the approver, timestamp, and the exact file version.

Naive approach

Many teams rely on:

Folder naming conventions (e.g., v1_FINAL.pdf).
Email chains with attachments.
Manual sign-off spreadsheets.

Problems:

Names don’t prove who signed.
Emails lose context when threads break.
Spreadsheets are easy to mis-edit.

Checkpoint: Don’t rely on file names or fragmented email threads to prove approvals.

Better approach

Use a structured audit trail attached to each document that captures:

Signer identity (name, email, authenticated method)
Approval timestamp
Document version or hash
Action type (approved, rejected, delegated)
IP address / device metadata
Audit event ID and chain-of-custody information

Why is this better?

A single source of truth for every approval
Easily searchable and exportable audit records
Strong support for electronic signature and compliance requirements

Checkpoint: A defensible audit trail always links actions to verified identities and exact document versions.

Example Use Cases

Change Orders: See who approved a cost increase and the timestamp for payment release.
RFIs: Track which engineer approved an RFI response and which version was attached.
Submittals: Keep approvals linked to exact spec versions to avoid on-site mistakes.
Claims & Disputes: Exported audit trails show a verifiable chain of custody.

Checkpoint: Audit trails help with daily site coordination and provide reliable evidence in disputes.

How BoldSign fits this workflow

BoldSign stores the audit trail with every signed document, so you do not juggle separate logs or spreadsheets. When a signature or approval happens, BoldSign records the event details and bundles them with the signed PDF and metadata. That means every change of order, RFI, or submittal can carry its own verifiable approval history.

What BoldSign captures for each audit event

Who acted – name and email, authenticated by the account method
When it happened – timestamp in UTC (ISO 8601)
What happened – action type and signer role
What file was seen – document hash for version proof
Where it happened – IP address and basic device info
A tamper-evident chain-of-custody log

Simple workflow to add audit trails to your project folder

Upload the document to BoldSign App.
Add signers and approvers in the correct order and require authentication
Send the approval or signature request.
Download the signed PDF and the attached audit trail.
Store both files in the job folder or project system.

Refer the details to Send Document in BoldSign App and for Audit Trail details.

Tip – Embed the audit summary into the signed PDF so a portable copy always includes the verification details.

BoldSign API examples

These examples show the idea. Replace YOUR_API_KEY and DOC_ID with your account values

cURL

    # Send document for signature request
    curl -X 'POST' \
      'https://api.boldsign.com/v1/document/send' \
      -H 'accept: application/json' \
      -H 'X-API-KEY: {your API key}' \
      -H 'Content-Type: application/json' \
      -d '{
        "DisableExpiryAlert": false,
        "ReminderSettings": {
            "ReminderDays": 5,
            "ReminderCount": 3,
            "EnableAutoReminder": true
        },
        "BrandId": "",
        "EnableReassign": true,
        "Message": "",
        "Signers": [
            {
                "Name": "Alex",
                "EmailAddress": "alexgayle@boldsign.dev",
                "SignerType": "Signer",
                "FormFields": [
                    {
                        "Id": "string",
                        "Name": "string",
                        "FieldType": "Signature",
                        "PageNumber": 1,
                        "Bounds": {
                            "X": 50,
                            "Y": 50,
                            "Width": 125,
                            "Height": 25
                        },
                        "IsRequired": true
                    },
                    {
                        "Id": "string",
                        "Name": "string",
                        "FieldType": "Label",
                        "PageNumber": 1,
                        "Bounds": {
                            "X": 150,
                            "Y": 250,
                            "Width": 125,
                            "Height": 25
                        },
                        "IsRequired": true,
                        "Value": "string",
                        "BackgroundHexColor": "string"
                    }
                ],
                "Locale": "EN"
            }
        ],
        "ExpiryDays": 30,
        "EnablePrintAndSign": false,
        "AutoDetectFields": false,
        "OnBehalfOf": "",
        "EnableSigningOrder": false,
        "UseTextTags": false,
        "SendLinkValidTill": "",
        "Files": [
            "data:application/pdf;base64,JVBERi0xLjcKJcfs..."
        ],
        "Title": "Sampledocument",
        "HideDocumentId": false,
        "EnableEmbeddedSigning": false,
        "ExpiryDateType": "Days",
        "ExpiryValue": 60,
        "DisableEmails": false,
        "DisableSMS": false,
        "MetaData": {
        "DocumentType": "new",
        "DocumentCategory": "Software"
      }
      }'
    //Download Audit trail
    curl -X GET 'https://api.boldsign.com/v1/document/downloadAuditLog?documentId={{:documentId}}' \
         -H 'accept: application/json' \
         -H 'X-API-KEY: {your-api-key}'

Node js

    //Send document for Signature request
    import { DocumentApi, DocumentSigner, FormField, Rectangle, SendForSign } from "boldsign"; 
    import * as fs from 'fs'; 
    const documentApi = new DocumentApi(); 
    documentApi.setApiKey("YOUR_API_KEY"); 
    const bounds = new Rectangle(); 
    bounds.x = 100;
    bounds.y = 50;
    bounds.width = 100; 
    bounds.height = 100; 
    const formField = new FormField();
    formField.fieldType = FormField.FieldTypeEnum.Signature; 
    formField.pageNumber = 1; 
    formField.bounds = bounds; 
    const documentSigner = new DocumentSigner(); 
    documentSigner.name = "David"; 
    documentSigner.emailAddress = "david@cubeflakes.com"; 
    documentSigner.signerType = DocumentSigner.SignerTypeEnum.Signer; 
    documentSigner.formFields = [formField];
    const files = fs.createReadStream("YOUR_FILE_PATH");
    const sendForSign = new SendForSign(); 
    sendForSign.title = "Agreement";
    sendForSign.signers = [documentSigner]; 
    sendForSign.files = [files]; 
    const documentCreated =documentApi.sendDocument(sendForSign);
    //Download Audit trail
    import { DocumentApi } from "boldsign";
    const documentApi = new DocumentApi();
    documentApi.setApiKey("YOUR_API_KEY");
    const documentStream = documentApi.downloadAuditLog("YOUR_DOCUMENT_ID");

Best practices

Enforce signer authentication (SSO or MFA) for critical approval.
Embed the audit summary directly into the signed PDF.
Use UTC timestamps to avoid time‑zone confusion.
Apply document hashes (such as SHA‑256) to prove file integrity.
Automate retention policies to meet legal and compliance needs.
Train field staff on how to read and verify audit trail details.

Summary table – Naive vs Better approach

Area tracked	Naive Approach	Better Approach
Document retrieval	Paper stacks or scattered emails, hard to find	Single signed PDF with an embedded audit trail, quick to locate
Approver identity	Name on a sheet or chat message, approval uncertain	Verified signer (email + timestamp), who exactly signed and when
Version control	Manual filenames like “v1_FINAL.pdf”, high risk	Versioned file with a document hash (exact match proof)
Dispute resolution	Slow and unclear, little proof	Fast verification using the audit JSON and signed PDF, clear evidence

Conclusion

An audit trail for construction docs turns messy email threads and ambiguous file names into a clear, verifiable record of who approved what (and when). Capture signer identity, timestamps, document versions, and device metadata; store records immutably; and present them in an easy-to-read export. The result: fewer disputes, faster approvals, and projects that keep moving.

Related blogs

Note: This blog was originally published at boldsign.com

Implementing Multi‑Factor Authentication for Zero‑Trust eSignatures

Vijay Amalan — Fri, 17 Apr 2026 05:26:00 +0000

An email link can show where a document was sent, but it does not always prove who actually signed it. A signature without authentication introduces uncertainty and weakens document security. Implementing signer authentication enhances trust by verifying the signer’s identity and ensuring signatures are legally valid and securely executed.

Multi‑Factor Authentication for Zero‑Trust eSignatures solve this by requiring every signer to verify their identity at the moment of signing. With authentication methods like Email OTP, SMS OTP, access codes, or ID verification, organizations can reduce fraud, strengthen compliance, and create more defensible signed documents, while BoldSign keeps the experience smooth and friction‑free.

Why zero-trust matters in eSignature workflows

Zero‑trust security follows one core principle: Never trust by default. Always verify.

Email access alone isn’t enough to confirm a signer’s identity. Every signer must verify who they are during signing.

With eSignatures widely adopted across HR, finance, healthcare, and legal teams, organizations need signatures that are:

Secure
Verifiable
Tamper-evident audit trails

This verification‑first approach ensures that every agreement meets those expectations, especially for high‑value or regulated documents.

Authentication vs verification in eSignatures

These terms are often used interchangeably, but they serve different purposes:

Authentication answers: Who is signing right now? This happens before or during the signing process.
Verification answers: Is the signed document authentic and unchanged? This happens after signing using audit trails and tamper‑evident records.

Zero‑trust eSignatures require both:

Strong authentication before signing
Strong verification evidence after signing

Why “email-only signing” is not enough

For high‑value or regulated documents, organizations need stronger access controls. Zero‑trust signing assumes any single factor can fail, which is why additional authentication steps are essential.

Email links are easy to use, but they don’t prove who is actually opening or signing a document. Risks include:

Shared inboxes
Account takeovers
Accidental or intentional forwarding

Why multi-factor authentication

MFA significantly reduces the risk of unauthorized access and identity fraud. For eSignatures, it provides stronger proof that the signer is exactly who they claim to be at the moment of signing.

Multi‑factor authentication combines two or more signals to confirm identity. For example:

Email link + one‑time passcode
Password + phone verification

MFA methods you can apply in BoldSign

BoldSign supports multiple signer authentication options, allowing you to verify signer identity without sacrificing usability.

Email OTP

A one-time password is sent to the signer’s email and must be entered to open the document.

Best for:

Low to medium risk workflows
Internal approvals
Faster adoption with minimal friction

SMS OTP

A one-time password is sent to the signer’s phone via SMS

Best for:

Medium to high risk workflows
External agreements where phone possession adds stronger assurance

Access Code

You set a code (PIN) and share it with the signer through a separate channel.

Best for:

Known parties (repeat vendors, employees)
Workflows where you want an extra verification step outside email

Identity Verification

Signer identity is verified using additional checks to confirm the signer is who they claim to be.

Best for:

High‑risk or regulated workflows
Legal, financial, and compliance‑driven agreements
Scenarios requiring stronger assurance of signer identity

ID verification for secure eSignatures

BoldSign’s ID verification serves as a high‑security authentication method by validating signer identity before access or signing. By combining government‑issued ID checks with biometric verification, it helps prevent fraud and ensures trust in compliance‑critical and high‑risk workflows.

Highlights:

Verifies signers using government‑issued photo IDs
Uses biometric selfie checks to prevent impersonation
Supports configurable verification frequency and attempt limits
Enables selective verification for specific signers
Available across web, mobile, and API‑based workflows

How to implement MFA for every signer in BoldSign

A consistent setup helps teams avoid missed steps.

Define document risk levels
Choose a default authentication method
Apply authentication settings in templates
Assign authentication to each signer in multi‑signer workflows
Confirm audit trails capture authentication events

BoldSign gives senders full control over how authentication is applied, making zero‑trust implementation flexible and scalable.

How audit trails complete the zero-trust model

Authentication reduces unauthorized access. Audit trails provide the evidence if questions arise later.

BoldSign audit trails record:

Who accessed and signed the document
When each action occurred
Which authentication method was used
IP address and device information
Document integrity through tamper detection

Together, authentication and audit trails support compliance reviews and dispute resolution.

Conclusion

Zero-trust eSignatures make digital signing more than just fast. They make it trustworthy. By requiring every signer to verify their identity before signing and backing each action with a detailed audit trail, organizations can reduce fraud, prevent disputes, and strengthen compliance across critical workflows.

With BoldSign, teams can apply the right level of authentication for every document, from simple approvals to high-risk agreements. Start with a baseline MFA method for all signers, then add stronger verification for sensitive transactions when needed. That way, every signature is not only easy to collect, but also easier to trust.

Make every signature easier to trust. Sign up for a free 30-day trial or connect with our support team for a personalized demo and see how zero-trust signing works in practice.

Related blogs

Note: This blog was originally published at boldsign.com

How to Submit a Data Subject Request with BoldSign

Vijay Amalan — Wed, 15 Apr 2026 05:27:34 +0000

For BoldSign users, we now have a streamlined process for submitting a data subject request for those individuals based in the European Economic Area (EEA) and UK.

Rights provided under the General Data Protection Regulation (GDPR), UK Data Protection Act 2018, and UK GDPR allow individuals to have more control over their data. In this blog, we will outline how BoldSign users in the EEA and UK can exercise these rights.

Overview of data subject rights

Access: You have the right to be informed about the personal data we process about you and to request access to it.
Rectification: You can ask us to amend or update your personal data if it’s inaccurate or incomplete.
Erasure: You may request that we delete certain personal data we hold about you.
Restriction: You can ask us to temporarily or permanently stop processing all or some of your personal data.
Object: You have the right to object to our processing of your personal data at any time, especially if it relates to your specific situation or involves direct marketing.
Data portability: You can request a copy of your personal data in electronic format and have the right to transmit that data to another service provider.

How to exercise rights with BoldSign

As part of our commitment to data protection and transparency, BoldSign provides clear mechanisms for individuals to exercise their rights under GDPR. If you wish to access, correct, delete, restrict, or transfer your personal data, or object to its processing, you may submit a formal request through our designated channels. We are dedicated to responding promptly and in accordance with applicable legal requirements.

1. Access the GDPR Request Form

If you wish to exercise your GDPR rights, you can make a request by filling out our GDPR Request Form. Our legal team will respond in a timely manner to your request in accordance with GDPR requirements.

2. Fill out the required fields

Customer Name: Enter your full name to help BoldSign identify your account.

Customer email address: Provide the email address associated with your BoldSign account.

Details: Describe your request clearly. Include specific information to ensure timely and accurate handling.

Requested action: Select the GDPR right you wish to exercise from the dropdown menu:

Request corrections to your data.
Request erasure of your data.
Request a copy of your data.
Request a restriction on the processing your data.
Object to data processing.
Exercise your data portability rights.
Other: specify what you would like us to provide.

3. Submit the form

Once completed, submit the form securely. BoldSign will acknowledge receipt and begin processing your request.

What to expect after submission

Upon submission of the form, our legal team will be notified. You should expect a timely receipt of submission. If any follow-up information is required, our team will reach out to you directly. We review each data subject access request carefully to ensure compliance and consideration.

BoldSign also maintains a GDPR representative. Individuals in the UK and EU can additionally submit their data subject requests through the following means:

EU Representative

Bird & Bird GDPR Representative Services SRL for EU
Avenue Louise 235
1050 Bruxelles
Belgium
EUrepresentative.syncfusion@twobirds.com

UK Representative

Bird & Bird GDPR Representative Services for UK
12 New Fetter Lane
London EC4A 1JP
United Kingdom
UKrepresentative.syncfusion@twobirds.com

Forem: Vijay Amalan

Reduce eSignature Drop‑Off: Practical Ways to Improve Completion Rates

How can you diagnose eSignature drop-off using a funnel?

How do you reduce eSignature drop-off step by step?

1) How do you improve “Sent → Delivered” rates?

2) How do you increase “Delivered → Opened” rates?

3) How do you reduce friction from “Opened → Started”?

4) Started → Completed: How do you cut friction inside the document?

5) How much authentication is too much for eSignatures?

Why do eSignature reminders consistently increase completion rates?

What common mistakes quietly lower eSignature completion?

What should you verify before sending an eSignature request?

What actually improves eSignature completion in the real world

Final key takeaways: How reducing friction improves eSignature completion rates

Webinar Show Notes: Salesforce Contract Management with BoldSign

Webinar recap

Highlights

Key takeaways

Helpful resources

Related blogs

Introducing BoldSign’s Free Phone Number QR Code Generator

What is a Phone Number QR code?

Why use a Phone Number QR code?

How to create Phone Number QR code for free?

Why choose BoldSign’s Phone Number QR code generator

Best ways to use Phone Number QR code

Conclusion

Related blogs

Construction Contract Basics: What Every Project Agreement Should Include

Why a solid construction contract matters

Common challenges in construction agreements

Delays and scheduling conflicts

Payment disputes

Contract interpretation issues

Changed conditions or scope creep

Subcontractor and quality disputes

Essential components of a construction contract

Identification of parties

Scope of work

Project timeline and schedule

Payment terms and schedule

Change order process

Responsibilities and warranties

Dispute resolution

Termination clauses

Force majeure and insurance

Contract documents list

Key steps in the contract approval workflow

Step 1: Draft the contract

Step 2: Review

Step 3: Negotiate and revise

Step 4: Approve and sign

Step 5: Execute and store

How BoldSign improves construction contract approvals

Conclusion

Related blogs

BoldSign Formula Fields: Automate Calculations in eSignature Documents

What problems do formula fields solve in eSignature documents?

How do BoldSign formula fields work?

Which fields, operators, and functions are supported?

How do you add formula fields to a document API request?

What does a vehicle sales agreement example look like with formula fields?

What best practices help formula fields work reliably?

Conclusion

Related blogs

ASP.NET Core Minimal APIs: When to Use Them and When Not To Use Them

What decision should you make: Minimal APIs or Controllers?

What will you build in this guide?

What prerequisites do you need before starting?

How does a Minimal API request flow work in production?

How do you avoid a giant Program.cs with Minimal APIs?

How do you build the production starter step by step?

How do you test and verify the API?

How do you add an integration test to prove endpoint wiring works?

What are the most common production mistakes with Minimal APIs and how do you fix them?

What did you achieve, and what should you do next?

Related blogs

Prevent “I Didn’t Sign This” Claims with ID Verification Methods & Audit Trails

What are repudiation claims

What is the risk of repudiation in electronic signatures

Why a solid construction contract matters 

Common challenges in construction agreements 

Delays and scheduling conflicts 

Payment disputes 

Contract interpretation issues 

Changed conditions or scope creep 

Subcontractor and quality disputes 

Essential components of a construction contract 

Identification of parties 

Scope of work 

Project timeline and schedule 

Payment terms and schedule 

Change order process 

Responsibilities and warranties 

Dispute resolution 

Termination clauses 

Force majeure and insurance 

Contract documents list 

Key steps in the contract approval workflow 

Step 1: Draft the contract 

Step 2: Review 

Step 3: Negotiate and revise 

Step 4: Approve and sign 

Step 5: Execute and store 

How BoldSign improves construction contract approvals 

Conclusion 