An e-signature flow is accessible when a signer who relies on a keyboard, screen reader, magnification, voice control, or who has a cognitive or motor disability can complete every step without help from the sender. That means opening the request, proving identity, reviewing the document, filling fields, applying a signature, and receiving the finished record.
Most teams test only the signature pad. The failures that stall real signers usually sit elsewhere: a one-time passcode that cannot be pasted, a session that expires mid-review, a sticky header in your host app that covers the focused field, or an invitation email whose only action is an image. Each one blocks a legally meaningful act, and each one is easy to miss in a happy-path demo.
This guide is written for the product manager who owns a signing experience, whether hosted, embedded, or built on an API. It proposes a Signing Journey Gate Model: seven all-required go/no-go gates mapped to WCAG 2.2. This is a proposed design from the eSignly Expert Team. It is not an established certification, not a conformance claim for any product, and not legal advice. It will help you decide what to test, who owns each surface, and what to do when a signer cannot finish.
- Who it is for: product managers, with engineering and compliance as supporting readers.
- What you get: a journey map, ownership table, seven release gates, an accommodation-handling pattern, and a vendor question list.
- What it is not: a substitute for counsel on which accessibility laws apply to you.
Key Takeaways
- Accessibility is a process property. WCAG conformance covers complete processes, so one inaccessible step (authentication, a time limit, a confirmation) can fail the whole signing journey.
- A vendor report is not your result. A conformance report is a dated vendor statement with a defined scope. Your host page, email templates, branding, and embedding code can change the outcome.
- Seven gates, all required. Invitation, authentication, document review, fields and errors, signature capture, time and session, and completion must each pass. Do not average them into a score.
- Security controls can conflict with accessibility. Knowledge-based questions, CAPTCHAs, and short passcode windows need accessible alternatives, not exceptions that nobody owns.
- Plan for the signer who cannot finish. Build an accommodation path with verified acknowledgment, a terminal-failure owner, and reconcile-before-retry behavior. Treat accommodation details as sensitive data.
- Legal scope varies. WCAG is a technical benchmark. Whether a given law requires it for your organization is a question for counsel.
Why Accessibility Breaks in E-Signature Flows
Key takeaway: A signing request is a chain of seven interactions owned by several parties. Accessibility usually fails at a handoff, not in the component everyone tests.
Signing looks like one screen. In practice it is a sequence: an email arrives, the signer authenticates, reads a document, completes fields, adopts a signature, confirms, and receives a copy. Different parts come from different owners: your email service, the signing vendor's hosted page or widget, your host application, a PDF generator, and an identity provider.
Signing is also high stakes. A signer who cannot get through an ordinary web form is inconvenienced. A signer who cannot get through a contract, consent form, or employment document may be unable to take up the agreement at all, and the sender may face stalled revenue, delayed onboarding, or a complaint. That asymmetry is why signing deserves its own accessibility review rather than inheriting the general website audit.
The table maps each stage to typical barriers and to the WCAG 2.2 success criteria most often involved. It is a planning aid, not an exhaustive audit list.
| Journey stage | Typical barrier | Primary WCAG references |
|---|---|---|
| 1. Invitation email | Image-only buttons, vague link text, missing language declaration | 1.1.1 Non-text Content, 2.4.4 Link Purpose (In Context), 3.1.1 Language of Page |
| 2. Identity check | OTP that blocks paste, CAPTCHA, knowledge-based questions as the only route | 3.3.8 Accessible Authentication (Minimum), 1.3.5 Identify Input Purpose |
| 3. Document review | Untagged or scanned documents, fixed-size viewer, no reading order | 1.3.1 Info and Relationships, 1.4.10 Reflow, 1.4.4 Resize Text |
| 4. Field completion | Unlabeled fields, color-only errors, small targets, focus hidden under sticky bars | 3.3.1 Error Identification, 3.3.2 Labels or Instructions, 2.5.8 Target Size (Minimum), 2.4.11 Focus Not Obscured (Minimum), 3.3.7 Redundant Entry |
| 5. Signature adoption | Draw-only pad, drag-to-place fields | 2.1.1 Keyboard, 2.5.7 Dragging Movements |
| 6. Time limits | Silent session expiry, no way to extend | 2.2.1 Timing Adjustable |
| 7. Confirmation and copy | Status not announced, no review-before-commit, inaccessible final record | 4.1.3 Status Messages, 3.3.4 Error Prevention (Legal, Financial, Data) |
Notice how many of these are new in WCAG 2.2. The W3C summary of what is new in WCAG 2.2 includes Redundant Entry, Accessible Authentication (Minimum), Target Size (Minimum), and Dragging Movements. Those criteria target the exact patterns signing flows rely on: re-keying signer details, typing passcodes, tapping small controls, and dragging signature fields onto a page.
If you have already worked on friction and abandonment, the product manager's guide to high-conversion eSignature UX covers the conversion side. This article covers the part that conversion dashboards hide: signers who never appear in the funnel because they could not get in.
How Most Teams Approach It, and Why That Fails
Key takeaway: Each common assurance method answers a narrower question than teams assume. None of them, alone, shows that a real signer can finish a real request.
Four approaches dominate. Each is reasonable. Each leaves a gap.
| Approach | What it can show | What it misses |
|---|---|---|
| Collect the vendor's conformance report | The vendor's own statement about specific pages, a WCAG version, and a date | Your host page, your email templates, your brand colors, your embed code, and any journey variant the report did not cover |
| Run an automated scanner | Detectable defects such as missing labels, contrast failures, and invalid markup | Whether reading order makes sense, whether instructions are understandable, whether focus behaves sensibly across an iframe boundary, whether a time limit traps someone |
| Demo the happy path with a keyboard | That a prepared tester can complete a clean request | Authentication failures, expired sessions, validation errors, resumed sessions, and mobile screen-reader behavior |
| Hand it to legal | Which obligations might apply | The engineering and design decisions that determine whether a signer succeeds |
The deeper failure is structural. WCAG conformance is defined for complete processes: if a page is one of a series of pages that present a process, all pages in that process must conform at the claimed level. The WCAG 2.2 specification sets this out in its conformance requirements. A signing journey is exactly such a process. A report that covers the document-signing page but not the authentication step does not tell you whether a signer can complete the process.
There is also a ownership problem. When signing is embedded, the vendor owns some surfaces, your team owns others, and nobody owns the seams. Procurement accepts a report, engineering integrates the widget, design applies brand colors, and the combined result is never evaluated as a whole. Intelligent teams fail here because each function did its job correctly.
Security teams add one more layer. Controls chosen to raise signer assurance, such as knowledge-based authentication or short passcode windows, can create cognitive or timing barriers. The framework for mapping MFA, KBA, and biometrics to long-term contract defensibility explains the assurance side. Accessibility asks a second question of the same control: can every signer actually use it?
The Signing Journey Gate Model: A Proposed Design
Key takeaway: Seven gates, each with evidence to collect and a no-go condition. Release only when every gate passes, or a named owner has approved a documented alternative path.
The model below is a proposed design from the eSignly Expert Team. It is not a formal standard, not a third-party certification, and not a claim that any product, including ours, meets it. It exists to turn WCAG 2.2 into decisions a product manager can run on a release checklist.
Two rules govern it. First, all gates are required. There is no weighted score, because a high average can hide a single gate that locks a signer out completely. Second, a gate may pass through an alternative path (for example, an assisted signing method) only if that path is documented, reachable without the failing step, owned by a named role, and tested.
| Gate | Question it answers | Evidence to collect | No-go if |
|---|---|---|---|
| G1. Invitation and entry | Can the signer understand and open the request? | Email tested in HTML and plain text with a screen reader; descriptive link text; language set; sender and document name stated in text | The only action is an image or a link labeled "click here" |
| G2. Authentication | Can the signer prove identity without recalling, solving, or transcribing? | Passcode accepts paste and autofill; an alternative route exists for any puzzle, recall, or knowledge-based step | A CAPTCHA or knowledge-based quiz is the only available route (3.3.8) |
| G3. Document review | Can the signer perceive the content that binds them? | Source documents with logical structure; viewer supports zoom, text selection, and screen-reader navigation; documented accessible alternative for scanned images | Required terms exist only as an untagged image with no alternative path |
| G4. Fields and errors | Can the signer complete and correct fields independently? | Programmatic labels; errors identified in text; targets of at least 24 by 24 CSS pixels or adequate spacing; focus never hidden by fixed elements; no redundant re-entry of known details | Focus disappears behind a sticky bar, or an error is conveyed by color alone (3.3.1, 2.4.11, 2.5.8, 3.3.7) |
| G5. Signature capture | Can the signer adopt a signature without a pointer or gesture? | Keyboard-only completion; typed or alternative adoption method where your policy and law allow; no drag-only placement | Freehand drawing is the only way to sign (2.1.1, 2.5.7) |
| G6. Time and session | Does the signer get enough time, and can they recover? | Time limits disclosed; extend option or reissue path; completed work preserved or recoverable | A session or passcode expires without warning and without a recovery path (2.2.1) |
| G7. Completion | Does the signer know what happened and get a usable record? | Review-and-confirm step before commit; status announced to assistive technology; final copy delivered in an accessible format or with an alternative | The commit action has no review, confirmation, or correction step, or success is signaled only visually (3.3.4, 4.1.3) |
How to run the gates
- Define the journey variants. Hosted link, embedded widget, API-built UI, mobile browser, reminder email, resumed session, and expired link are all variants.
- Build a test matrix. Keyboard only; at least two screen readers across desktop and mobile; browser zoom at 200 percent and 400 percent; voice control; high-contrast or forced-colors mode.
- Test with real tasks. "Open the request, authenticate, correct a deliberate error, sign, and find the final copy" beats "check the page."
- Record evidence per gate. A short note, a recording, or a defect ID. "Looked fine" is not evidence.
- Apply the rule. Any no-go stops release, or triggers a documented alternative path approved by the owner of that path.
One point on G2 deserves emphasis. WCAG 2.2 criterion 3.3.8 says a cognitive function test, such as remembering a password or solving a puzzle, must not be required for any authentication step unless an alternative, an assisting mechanism, object recognition, or personal content is provided. The W3C notes that password-manager support and copy and paste are examples of assisting mechanisms. For signing, that translates into a simple test: can a signer paste a passcode from their email? Knowledge-based questions generally rely on recall, so they need an accessible alternative route.
What This Means for the Product Manager: Ownership and Accommodation Paths
Key takeaway: You cannot delegate the seams. Map who owns each surface, then design an accommodation path that fails safe, preserves privacy, and never guesses at outcomes.
Map surface ownership before you test
The ownership table below reflects typical arrangements, not a guarantee. Confirm each cell against your contract, your documentation, and your actual implementation.
| Surface | Hosted signing page | Embedded widget or iframe | Custom UI built on an API |
|---|---|---|---|
| Signing controls and fields | Vendor | Vendor, as configured by you | Your team |
| Host page chrome (headers, cookie banners, sticky bars) | Not applicable | Your team | Your team |
| Focus handling when the signing frame opens and closes | Browser navigation | Your team and vendor jointly | Your team |
| Frame title and surrounding instructions | Not applicable | Your team | Your team |
| Email templates and branding colors | Shared, depending on customization | Shared | Your team |
| Source document structure | Your team | Your team | Your team |
| Return page after signing | Your team | Your team | Your team |
Two practical consequences follow. First, with an embedded flow, your host page can fail a signer even if the vendor's controls are fine: a fixed cookie banner covering the focused field is your defect (2.4.11). Second, a return-page message that says "Signed" is a UX confirmation, not proof of signing. The article on why callbacks and return URLs are not proof of signing explains why your system should confirm completion from authoritative state, and the same principle applies to announcing success to assistive technology. For the broader integration choice, see the guide to embedded eSignature APIs versus third-party portals.
Design the accommodation path
No flow is perfect for every signer. Plan for the signer who says, or whose behavior suggests, "I cannot complete this." Typical responses include extending the deadline, reissuing the request through another channel, switching to assisted or in-person signing, or supplying an alternative document format. Each response is a state change on a consequential request, so it needs the same discipline as any other mutation.
- Verified acknowledgment. Mark an accommodation "applied" only after reading authoritative request state and confirming the change (for example, the new deadline). A 200 response or a queued job is not confirmation.
- Terminal failure. If the digital path cannot be fixed within a defined window, route to a named human owner with a documented fallback. Do not let the request silently expire.
- Uncertain input. A signer who goes silent, abandons a step, or reports trouble has not declined. Record the state as unresolved. An unknown result means completion could not be confirmed, not success and not verified failure.
- Tenant-safe idempotency. Bind a durable, tenant-scoped operation ID to a hash of the approved change. Reject reuse of that ID with a different payload. Treat a legitimately later accommodation as a new operation with a new ID.
- Atomic claim. Only one worker may act on an operation at a time, claimed through a conditional database update.
- Reconcile before retry. After an ambiguous timeout, read the vendor's current state before sending anything again. The reconcile-first recovery design and the deadline ledger design cover the mechanics in depth.
- Privacy ownership. An accommodation request can reveal health or disability information. Store the minimum needed (for example, "alternative method applied") rather than the reason, restrict access, and keep identifiers such as signer emails and request IDs out of general-purpose logs. The privacy-safe telemetry design shows how to instrument without leaking.
The sketch below is illustrative pseudocode. It is not an official eSignly API contract, and it assumes nothing about provider-side idempotency or conditional updates. Because the target API may not support a conditional mutation, the expected-deadline check is a read-compare-then-write guard, not a compare-and-swap. The design compensates by serializing work per signing request through the claim, and by escalating to a human when state differs from what was approved.
// ILLUSTRATIVE ONLY: adapt to the exact, documented provider API. async function applyDeadlineAccommodation(db, vendor, req) { const payloadHash = sha256(canonicalJson({ signingRequestId: req.signingRequestId, action: 'EXTEND_DEADLINE', expectedDeadline: req.expectedDeadline, newDeadline: req.newDeadline })); // Durable, tenant-scoped identity bound to the approved payload await db.exec( `INSERT INTO accommodation_ops (tenant_id, op_id, payload_hash, state) VALUES ($1, $2, $3, 'approved') ON CONFLICT (tenant_id, op_id) DO NOTHING`, [req.tenantId, req.opId, payloadHash]); const op = await db.one( `SELECT payload_hash FROM accommodation_ops WHERE tenant_id = $1 AND op_id = $2`, [req.tenantId, req.opId]); if (op.payload_hash !== payloadHash) { throw new ConflictError('op_id reused with a different payload'); } // Atomic claim: exactly one worker proceeds const claim = await db.exec( `UPDATE accommodation_ops SET state = 'in_flight', claimed_by = $3 WHERE tenant_id = $1 AND op_id = $2 AND state IN ('approved', 'unknown') RETURNING reconcile_required`, [req.tenantId, req.opId, req.workerId]); if (claim.rowCount === 0) return; // owned elsewhere or already terminal // After an ambiguous timeout, read authoritative state before any retry if (claim.rows[0].reconcile_required) { const live = await vendor.getRequestState(req.signingRequestId); if (sameInstant(live.deadline, req.newDeadline)) { return markVerified(db, req); // already applied } if (!sameInstant(live.deadline, req.expectedDeadline)) { return escalateToHuman(db, req, live); // changed by someone else } } try { await vendor.extendDeadline(req.signingRequestId, req.newDeadline); const after = await vendor.getRequestState(req.signingRequestId); if (sameInstant(after.deadline, req.newDeadline)) { return markVerified(db, req); // verified acknowledgment } return markUnknown(db, req); // completion not confirmed } catch (err) { if (isTimeoutOrNetwork(err)) return markUnknown(db, req, { reconcile: true }); return markTerminalFailure(db, req, err); // route to named owner } }
Why This Fails in the Real World: Common Failure Patterns
Key takeaway: These failures come from seams between owners and from controls designed for one goal colliding with another. The scenarios below are illustrative composites, not customer results.
Pattern 1: The embedded frame that passed review and still trapped a signer
Illustrative scenario. A team embeds a signing frame inside its customer portal. The vendor's standalone signing page is documented as conforming. In the portal, a fixed consent banner and a sticky navigation bar sit above the frame. A keyboard user tabs through the fields and the focus indicator slides under the sticky bar, so they cannot see which field is active. The frame has no descriptive title, so a screen-reader user hears only "frame" with no context.
Why intelligent teams still fail: procurement verified the vendor page, engineering verified that the widget loaded, and design verified the brand colors. Nobody was assigned the journey as experienced inside the host. The seam had no owner.
Pattern 2: The security control that became a lockout, then a duplicate
Illustrative scenario. A finance workflow sends a request with a short-lived passcode. A signer who uses a screen reader and needs extra time lets the passcode lapse. Support, trying to help, resends the request. The first attempt had timed out in the integration layer without a clear result, so the worker retried blindly. Now two active requests exist for the same agreement. One is signed, and the other remains open and later triggers an unnecessary reminder sequence.
Why intelligent teams still fail: the passcode window was set by a security default, the resend was an operational reflex, and the retry logic treated an ambiguous timeout as a failure. There was no operation identity, no reconcile step, and no owner for "signer cannot complete." The fix is the pattern described in the previous section, plus a recovery path at G6 that does not require starting over.
Pattern 3: The accessible product, undone by customization
Illustrative scenario. A conformant default theme is replaced by a brand palette with light gray text on a white background and tiny icon-only buttons. A reminder email is redesigned as a single image. Nothing in the signing component changed, yet G1, G4, and contrast expectations now fail.
Why intelligent teams still fail: accessibility was validated once, at procurement. Branding and template changes shipped through a different approval path with no accessibility gate.
Pattern 4: The scanned PDF that nobody can read
Illustrative scenario. A legacy process generates agreements by scanning a signed template, then sending the image for signature. Screen readers find no text. The team assumes the signer can read it visually, which excludes anyone who cannot.
Why intelligent teams still fail: document creation belongs to a different team than the signing experience. The signing vendor receives whatever it is given.
Failure signals to watch
- Support tickets that say "I could not get the code in" or "the page timed out" with no tag for accessibility.
- Completion rates that drop for requests with longer documents or more fields, with no investigation of why.
- Branding or template changes that bypass the release checklist.
- A vendor report whose date, scope, or WCAG version nobody on your team has read.
- Duplicate active requests for the same agreement after a support intervention.
Risks, Constraints, and Trade-Offs
Key takeaway: WCAG is a technical benchmark, not a statement of what the law requires of you. Treat security, accessibility, and legal scope as three questions that must be answered separately.
Legal scope: a reader-specific question
Do not infer a legal obligation from this article. The table lists common reference points so you can brief counsel; it is not a determination for your organization.
| Context | Reference point | What to confirm with counsel |
|---|---|---|
| US state and local government entities | The ADA Title II web and mobile app rule adopts WCAG 2.1 Level AA as the technical standard, per the ADA.gov fact sheet | Current compliance dates, exceptions, and whether contracted vendor content is in scope |
| US federal agencies and federal procurement | Section 508 requirements, summarized at Section508.gov | Which technical standard applies to your contract and how conformance must be documented |
| US private-sector organizations | The ADA and state civil-rights laws; WCAG is widely used as a technical benchmark | Whether and how the law applies to your online signing experience and customers |
| EU and other jurisdictions | National and regional accessibility legislation and procurement rules | Scope, thresholds, and the standard referenced for your product or service |
On the E-SIGN Act specifically: it does not prescribe WCAG. Its consumer-consent provisions, found at 15 U.S.C. 7001, concern certain legally required disclosures to consumers, including consent and a reasonable demonstration that the consumer can access the information in electronic form. Those provisions apply to particular disclosures, not every signing. Whether they apply to your document types is a legal question.
Trade-offs between security and accessibility
| Control | Accessibility tension | Design response |
|---|---|---|
| Knowledge-based authentication | Relies on recall, a cognitive function test under 3.3.8 | Offer an alternative method with comparable assurance, such as a verified-channel link or assisted identity check, and document who approves it |
| CAPTCHA | Puzzles block some users | Prefer risk-based checks that do not require solving; where a puzzle remains, provide an alternative |
| Short passcode lifetime | Penalizes slower input methods and assistive technology | Allow paste and autofill, announce the time limit, permit re-issue without restarting the document |
| Freehand signature only | Excludes keyboard and some assistive-technology users | Provide an adoption method that works without gestures, within what your jurisdiction and document type accept |
| Camera-based ID verification | Positioning, lighting, and device dexterity barriers | Provide an assisted path or an alternative verification route |
Every alternative path carries its own cost: another flow to test, another assurance level to justify, another operational owner. That is the trade-off, and it is usually worth paying. The cost of a missing alternative is a signer you cannot serve.
Limits of this model
- Passing all seven gates does not certify WCAG conformance, legal compliance, or production readiness. It is a release-decision aid.
- The model covers the signing journey, not your whole product or your document templates in depth.
- Assistive-technology behavior varies by browser, operating system, and version. Re-test when any of them changes materially.
2027 Update
For planning purposes, two points are worth anchoring. First, the US Department of Justice published an interim final rule in April 2026 that extended the Title II web rule compliance dates to April 26, 2027 for public entities with populations of 50,000 or more, and April 26, 2028 for smaller entities and special district governments, as described in the Federal Register notice. Dates and rules can change again, so check the current text. Second, WCAG 2.2 is designed so that content meeting it also meets WCAG 2.1, which means a team targeting 2.2 is not building on a different foundation from one targeting 2.1. Newer WCAG versions may follow. The durable practice is not a version number: test complete journeys, keep evidence, and assign owners.
A Lower-Risk Operating Model: Procure, Gate, Test, Monitor
Key takeaway: Make accessibility a recurring release control with named owners and evidence, not a one-time procurement document.
Step 1: Procure with specific questions
When evaluating any signing vendor, including eSignly, ask for primary documentation and read its scope. Vendor statements describe the vendor's own product under defined conditions. They do not describe your host page or customizations.
- Which WCAG version and level does the conformance documentation cover, and what is its date?
- Does the scope include the complete signing process: invitation, authentication, review, fields, signature, confirmation, and final copy?
- Which journey variants are covered: hosted, embedded, mobile browser, resumed session, expired link?
- What are the known exceptions, and what is the remediation timeline?
- Which authentication methods have accessible alternatives, and can a tenant configure them?
- Can time limits and reminders be configured, and can a signer extend or reissue without losing work?
- What assisted or alternative signing options exist? (For eSignly, review the in-person signing capability and the API widget documentation against your gates.)
On security and compliance, eSignly publishes its stated certifications and controls on its security and compliance pages. Those statements address security and regulatory frameworks. They are separate from accessibility conformance, which you should request and evaluate separately for any vendor.
Step 2: Put the gates in the release process
Add the seven gates to the definition of done for any change to signing screens, email templates, branding, authentication settings, timeouts, or the host page that embeds signing. Assign an owner for each gate, and require a recorded outcome: pass, fail with defect ID, or alternative path with approver.
Step 3: Test the failure paths, not only the success path
- Enter a wrong value and check that the error is explained and focusable.
- Let the passcode or session lapse and check the recovery path.
- Resume a half-completed request.
- Open the final confirmation and the signed copy with assistive technology.
- Trigger the accommodation path and confirm the reconcile-first behavior after a simulated timeout. The failure injection plan for backend teams offers a structure for this.
Step 4: Monitor with privacy in mind
Track aggregate indicators such as authentication failure rate, expiry-before-completion rate, and accommodation request volume. Segment by journey variant, not by individual. Keep personal identifiers out of logs, and keep accommodation reasons out of analytics entirely.
Step 5: Review on a schedule and on change
Re-run the gates when a vendor ships a new signing interface, when you change authentication, when branding changes, and on a fixed cadence. Treat a vendor release note as a trigger for retesting.
Want to run these seven gates on a real signing flow?
Set up a test request, walk it with a keyboard and a screen reader, and record what passes and what does not. Evidence beats assumptions.
Start with eSignly's free plan and test your own journey against the gates.
Free TrialConclusion: Decisions to Make Before Your Next Signing Release
Accessibility in e-signature is a question of whether a real signer can finish a real request. The decisions below keep that question answerable.
- Name an owner for the whole journey. Assign one role accountable for the seven gates across vendor, host page, email, and documents.
- Read the scope of every conformance statement you rely on. Confirm version, date, journey coverage, and exceptions, and record what remains your responsibility.
- Remove single-route dependencies. Where authentication, signature capture, or timing leaves one route, add a documented alternative or accept a no-go.
- Build the "cannot complete" path now. Define verified acknowledgment, a terminal-failure owner, reconcile-before-retry behavior, and minimal, access-controlled accommodation records.
- Take the legal scope to counsel. Bring the reference-point table and your document types, and get an answer specific to your organization and jurisdictions.
About this guidance
eSignly has provided online eSignature, API, and on-premises signing software since 2014 and states that it serves more than 100,000 users. eSignly states that it maintains ISO 27001, SOC 2, HIPAA, GDPR, 21 CFR Part 11, and PCI DSS compliance; see the security and compliance pages for the scope of those statements, and note that they are separate from accessibility conformance. The Signing Journey Gate Model is a proposed design offered for evaluation, not a certification. Reviewed by the eSignly Expert Team.
Frequently Asked Questions
Is WCAG conformance legally required for e-signature flows?
It depends on who you are and where you operate. The E-SIGN Act does not prescribe WCAG. The ADA Title II web rule names WCAG 2.1 Level AA for state and local government entities. Other organizations may face different laws, procurement requirements, or contract terms. Ask counsel which obligations apply to your organization and document types.
Does a vendor's accessibility conformance report mean our embedded signing flow is accessible?
No. A conformance report is a vendor statement about specific pages, a WCAG version, and a date. Your host page, iframe titles, focus handling, email templates, branding, and source documents can change the result. Because WCAG conformance covers complete processes, test the whole journey in your own environment.
Can we use knowledge-based authentication and still meet WCAG 2.2?
Only with care. Knowledge-based questions rely on recall, which is a cognitive function test under criterion 3.3.8. The criterion allows such a step if an alternative method, an assisting mechanism, object recognition, or personal content is provided. In practice, offer an accessible alternative route and document its assurance level.
Is a typed signature acceptable instead of a drawn one?
- The E-SIGN Act defines an electronic signature broadly as an electronic sound, symbol, or process attached to or logically associated with a record and executed or adopted with the intent to sign.
- Whether a typed or adopted signature is acceptable for a specific document depends on the law, the document type, and your own policy.
- Confirm with counsel, particularly for documents that carry special formalities.
How should we test an e-signature flow for accessibility?
Run task-based tests across a matrix: keyboard only, at least two screen readers, zoom to 400 percent, voice control, and forced-colors mode. Cover failure paths as well as success: wrong inputs, expired sessions, resumed requests, and the final signed copy. Record evidence for each gate.
What should we store when a signer asks for an accommodation?
Store the minimum needed to operate and audit the change: that an alternative method or extension was applied, when, and by whom. Avoid storing the reason, keep access restricted, and keep signer emails and request IDs out of general logs, since identifiers can themselves be sensitive.
What if our system times out while extending a deadline for a signer?
Do not retry blindly. Mark the operation as unknown, read the authoritative request state, and compare it to the approved change. If the change is already applied, record it as verified. If the state differs from what was approved, escalate to a human owner instead of overwriting.
Is your signing flow ready for the signer who needs it most?
Hosted, embedded, or API-built, every journey has seams. Find them before a signer does.
Explore eSignly's eSignature SaaS, API, and on-premises options, then test your own flow.
Free TrialCompliance
This article is most relevant for product / platform owner who need to prepare a compliant signing process. Use the related eSignly path to compare plans, API options, compliance fit, and implementation next steps.
Reviewed for electronic signature decision makers
This guide is reviewed for clarity, legal and operational relevance, service alignment, and practical conversion path before being connected to an eSignly plan or API workflow.
For regulated, high-volume, or customer-facing workflows, validate legal duties, plan assumptions, and integration requirements with your internal stakeholders before rollout.

