MobTouch · Product
DocuSend.io — making document workflows feel like software
A document campaign platform that combines visual template design, AI-assisted field detection, recipient data, preflight validation, deterministic generation, delivery, and completion tracking in one coherent workflow.
Role: Founder / Product engineer
- Document automation
- AI-assisted productivity
- Multi-tenant SaaS
Origin
The story
DocuSend began with a simple observation: every organization eventually runs into the same paperwork problem.
Contracts, agreements, onboarding documents, waivers, applications, disclosures, tax forms, and other paperwork must be completed by many people. The individual technologies already exist—electronic signatures, PDF editors, templates, CSV imports, and email automation—yet the overall experience still feels surprisingly manual.
Preparing documents is tedious. Placing signature fields is repetitive. Managing hundreds of recipients becomes a spreadsheet exercise. Small mistakes often require starting over. The workflow feels like a collection of disconnected tools rather than one coherent product.
I wanted to rethink the experience from the perspective of the person sending documents rather than the platform processing signatures.
The goal was not simply to build another e-signature application. It was to build the document platform I always wished existed: software that handles repetitive preparation while keeping people in control of the decisions that require judgment.
Journey
The workflow behind the documents
Beyond electronic signatures
Most people think document platforms are about collecting signatures. In reality, a signature is only one step in a much larger lifecycle.
DocuSend focuses on the sender’s complete workflow. Signing becomes a natural outcome of a system that begins with a reusable template and ends with delivery, completion, history, and auditability.
- Create reusable templates and design document layouts
- Identify and review interactive fields
- Manage organizations, members, and roles
- Import recipients and map CSV columns
- Preview personalized documents before launch
- Send campaigns and track every recipient
- Monitor completion and preserve document history
The real problem is preparation at scale
Capturing one signature is straightforward. Preparing hundreds or thousands of personalized documents accurately is the hard part.
That shifted the product center away from the final signature and toward mapping, validation, preview, and confidence before anything is sent.
- Which fields belong to each recipient?
- Where should those fields appear on every page?
- How should CSV columns map into the template?
- What happens when required data is missing?
- How can mistakes be detected before sending?
- How can a large campaign be reviewed safely?
AI as a productivity tool
Artificial intelligence is not the product. It is the assistant that helps people prepare documents faster.
Instead of drawing every field manually, AI can identify likely signatures, initials, dates, names, addresses, email addresses, text inputs, and checkboxes. Every suggestion remains reviewable and adjustable.
The objective is not automation for its own sake. It is eliminating repetitive work without sacrificing confidence.
Built around campaigns
A campaign is one of the central domain ideas in DocuSend. It combines one template, many recipients, personalized values, delivery state, progress, and completion into a single operational unit.
Organizations can prepare an entire campaign, validate it, preview individualized documents, and launch distribution with a clear understanding of what will happen.
The model fits recurring workflows such as onboarding, HR paperwork, compliance documents, customer agreements, vendor contracts, waivers, and applications.
Safe by design
Sending documents at scale leaves very little room for error. Validation is therefore part of the product architecture rather than a final warning dialog.
The system is designed to discover mistakes while they are still cheap to fix—before recipients receive an email or a generated document becomes part of the campaign history.
- CSV shape and recipient validation
- Template and field validation
- Required-field and missing-data checks
- Per-recipient document previews
- Dry-run generation
- Final campaign review before launch
Visual document editing
Traditional PDF editing often feels disconnected from the data the document is meant to collect. DocuSend treats a template more like modern design software.
The PDF remains the visual canvas while structured metadata describes every interactive field. That shared model powers editing, AI suggestions, data mapping, preview, and deterministic generation.
- Drag-and-drop fields and resizing
- Alignment guides and measurement rulers
- Snap-to-grid behavior
- Multi-page documents
- Layered annotations
- Live preview with recipient data
Multi-tenant from the beginning
DocuSend was designed as a multi-tenant SaaS platform rather than a single-user document utility.
Organizations have isolated workspaces while sharing the underlying infrastructure. Membership, roles, storage, queries, campaign execution, and audit history all respect that boundary.
The domain model is built around organizations, members, roles, templates, campaigns, documents, recipients, and audit events so the platform can grow with the complexity of the teams using it.
Real-world impact
DocuSend is actively used in a production workflow where dozens of documents may need to be prepared and sent each day.
One customer already had access to DocuSign, but it did not solve the broader operational problem. Their challenge was not simply obtaining electronic signatures—they needed an end-to-end system for the work surrounding every signature.
- Prepare reusable templates
- Import recipient data
- Map source data into documents
- Generate personalized documents at scale
- Review documents before sending
- Distribute dozens of documents efficiently
- Track status and completion
- Manage the workflow without repetitive manual work
“I don’t know what we would have done without DocuSend.”
That feedback captures the reason the product exists.
DocuSend is not intended to replace every capability of a large e-signature platform. It solves a different problem: making high-volume document operations dramatically simpler from beginning to end.
The value is not just the signature. It is everything required to move dozens of accurate, personalized documents from source data into recipients’ hands every day.
The product philosophy
Every repetitive workflow eventually deserves better software. Creating hundreds of personalized documents should not require hours of manual editing.
Artificial intelligence should remove repetitive work, not introduce uncertainty.
The software should handle repetition so people can focus on the decisions that actually require human judgment.
Context
The problem and my role
Problem
Electronic signatures, PDF editors, CSV imports, and email automation already exist, yet preparing personalized documents for many recipients remains fragmented and manual. The real challenge is not collecting a signature—it is accurately preparing, validating, previewing, sending, and tracking hundreds or thousands of individualized documents.
Role
Designed and built DocuSend end-to-end as a MobTouch product: document and campaign domain models, visual multi-page editor, AI-assisted field detection, CSV mapping, validation and preview, multi-tenant workspaces, background generation and delivery, secure storage, authentication, audit history, webhooks, and completion tracking.
Constraints
- Interactive fields must remain precise across PDF pages, dimensions, scaling, and coordinate systems
- AI suggestions must accelerate setup without introducing uncertainty into final document generation
- CSV columns, template fields, and recipient values need clear, reversible mapping
- Missing or invalid data must be detected before a campaign reaches any recipient
- Large campaigns require reliable asynchronous generation, delivery, retry, and progress tracking
- Templates must remain reusable and versioned while preserving historical campaign output
- Organizations, members, roles, documents, and audit history require strict tenant isolation
- PDFs and generated documents need secure storage and controlled access
- Email, signature-provider, and webhook events must converge into one understandable status model
System
Architecture
System map
The document campaign lifecycle
A reusable template becomes a validated set of personalized documents, then moves through asynchronous delivery, completion, and audit history.
- 01
Template and PDF
Upload a document and establish a reusable, versioned template
- 02
AI-assisted field detection
Propose likely signatures, dates, names, text fields, and checkboxes
- 03
Visual review
Adjust positions, dimensions, field types, and required behavior
- 04
Recipients and mapping
Import CSV data and map columns to structured template fields
- 05
Preflight and preview
Validate required data and inspect personalized documents before launch
- 06
Generation and delivery
Workers create deterministic output and send through the selected channel
- 07
Tracking and completion
Webhooks, delivery state, completion events, notifications, and audit history
System map
The SaaS and processing architecture
The interactive application, tenant-scoped data, secure files, and asynchronous processing remain separate but converge around the campaign state model.
- 01
Organization workspace
Members and roles define tenant-scoped access to templates and campaigns
- 02
Next.js application
Visual editor, recipient mapping, previews, campaign review, and results
- 03
Application services
Node.js, Better Auth, PostgreSQL, and Drizzle enforce domain and tenant boundaries
- 04
Secure document storage
Versioned PDFs, generated documents, and controlled object access
- 05
Background workers
PDF processing, generation, delivery, retry, and asynchronous status updates
- 06
Delivery integrations
Resend, DocuSign, webhooks, and completion notifications
- 07
Campaign observability
Recipient-level progress, failures, audit events, analytics, logs, and traces
Execution
What I built
- Built a visual, multi-page PDF editor with drag-and-drop fields, resizing, rulers, guides, snapping, annotations, and live preview.
- Modeled every interactive field as structured template metadata shared across editing, AI detection, mapping, validation, and generation.
- Added AI-assisted document understanding that proposes likely field types and locations for human review.
- Designed a campaign workflow that imports recipients, maps CSV columns, validates data, previews individualized output, and requires review before launch.
- Kept final document generation deterministic and reproducible after the AI-assisted preparation step.
- Implemented organizations, membership, roles, tenant-scoped templates, campaigns, recipients, documents, and audit events.
- Designed background workers for PDF processing, personalized generation, email delivery, retries, and status updates.
- Integrated secure cloud object storage, versioned templates, and controlled document access.
- Connected Resend, DocuSign, delivery events, webhooks, and completion notifications to campaign and recipient status.
- Added operational visibility for sent, completed, and failed deliveries at both campaign and recipient levels.
Tradeoffs
Technical decisions
Campaign as a first-class aggregate
- Decision
- Model the template, recipients, personalized values, validation, delivery, and completion as one campaign lifecycle.
- Why
- The sender thinks in terms of a coordinated business process, not hundreds of unrelated document sends.
- Tradeoff
- The aggregate creates stronger consistency and visibility, but requires careful state transitions and idempotent asynchronous processing.
Probabilistic preparation, deterministic output
- Decision
- Use AI to suggest fields during setup while keeping reviewed template metadata and final document generation deterministic.
- Why
- AI is well suited to reducing repetitive discovery work; recipients and compliance workflows still require reproducible output.
- Tradeoff
- Human review remains part of the workflow, which intentionally limits fully autonomous setup in exchange for confidence.
One coordinate model across the product
- Decision
- Represent fields as structured metadata that can be transformed consistently between the editor viewport and the underlying PDF page.
- Why
- Editing, preview, AI suggestions, data mapping, and generation must all agree on exactly where a field belongs.
- Tradeoff
- Multi-page scaling, rotations, and responsive editor dimensions demand disciplined coordinate conversions and extensive visual testing.
Preflight before irreversible work
- Decision
- Layer CSV, field, required-data, recipient-preview, dry-run, and campaign-review checks ahead of delivery.
- Why
- A sender should discover mistakes before generated documents or emails reach recipients.
- Tradeoff
- More checkpoints add setup steps, so the interface must explain issues clearly and keep correction fast.
Asynchronous campaign execution
- Decision
- Move PDF processing, personalized generation, delivery, retries, and webhook handling into background workers.
- Why
- Campaign work is long-running and failure-prone; it should not depend on one browser request or one serverless execution window.
- Tradeoff
- Background processing introduces queues, retries, idempotency, and eventual consistency that must remain visible to users.
Tenant isolation in the domain model
- Decision
- Scope access, queries, storage, campaigns, and audit events through organizations and role-aware membership.
- Why
- Multi-tenancy is a security and data-model concern, not a UI filter that can be added after the product grows.
- Tradeoff
- Every service boundary and asynchronous task must carry and enforce tenant context consistently.
Value
Product impact
User impact
Replaces repetitive field placement, spreadsheet coordination, manual personalization, and disconnected delivery tracking with one reviewable campaign workflow.
Business impact
Turns recurring paperwork into a reusable SaaS process with organizational workspaces, templates, audit history, asynchronous execution, and multiple delivery paths.
Results
Outcomes
- Actively used in a production workflow where dozens of personalized documents may be prepared and sent each day.
- An end-to-end workflow from PDF upload and template design through recipient mapping, preview, launch, delivery, and monitored completion.
- A reusable campaign model for recurring onboarding, HR, compliance, agreement, waiver, and application workflows.
- A clear boundary where AI reduces repetitive preparation while deterministic systems preserve document confidence.
- A live product presence at docusend.io for demonstrations, onboarding, and product feedback.
Reflection
Lessons learned
- “The hardest part of document automation is not capturing a signature—it is preparing personalized documents accurately at scale.”
- “AI creates the most value when it accelerates reversible preparation while deterministic systems own irreversible output.”
- “Trust comes from visibility: validation, preview, progress, failure states, and audit history are core product features.”
- “A campaign is more than a batch job; it is the domain model that connects people, data, documents, delivery, and completion.”
Tools
Stack
Next case study
Route & Ride — plan, assign, prove delivery →