Major

Automate Claim Document Signing: Guidewire ClaimCenter + DocuSign

Connect Guidewire ClaimCenter activities to DocuSign status events, keep signature progress in a durable app, and route exceptions for adjuster review before payment readiness changes.

Ritvij GautamUpdated
automate-claim-document-signing-guidewire-unsplash-1775163024488-e88e4a71179f.jpg

TL;DR: what you'll build. Claims teams on Guidewire ClaimCenter Cloud lose adjuster time chasing signatures DocuSign already collected. This guide shows how to automate claim document signing Guidewire teams currently track by hand: a Major app holds the claim-to-envelope ledger, a workflow handles status updates and an agent resolves mismatched events. Payment readiness moves to adjuster review, never straight to release.

How the claim signing automation works

Connect a ClaimCenter activity that requires a signature to a DocuSign envelope. DocuSign Connect status events then feed back into a durable record that tracks every signer against that claim. Three parts share the work:

  • A Major app holds the claim-to-envelope mapping and the full event history.
  • A deterministic workflow does the repeatable polling and status updates.
  • An agent only steps in when a signature event does not cleanly match a claim.

Who owns this problem

The claims operations or claims compliance group running ClaimCenter Cloud owns this problem. It shows up every week an adjuster has to ask "did the insured sign the release yet?"

For the broader pattern of agents working inside insurance systems, see AI agents for insurance. For the DocuSign side, see DocuSign AI workflows.

Where claim-signature work gets stuck

A settlement agreement, a proof-of-loss form or a liability release goes out through DocuSign, and the trail goes cold inside ClaimCenter. The sending adjuster has a dozen other open claims, and nobody watches DocuSign for that one envelope.

A week later, during a file review or at month-end close, someone discovers a signed document has been sitting completed for days while the ClaimCenter activity still shows open. Worse, a claim might show "signed" when one of three required co-insureds never signed at all.

What Guidewire already offers

Guidewire lists a DocuSign integration for ClaimCenter on its Marketplace, and the two companies announced a DocuSign offering for PolicyCenter and ClaimCenter in 2025. That listing covers collecting, tracking and storing signatures inside ClaimCenter, so check it before building anything custom.

Neither source documents the cross-system lifecycle in public detail:

  • How an envelope status change gets correlated back to the right claim and activity.
  • What happens to a declined or expired envelope.
  • Who gets notified when a required signer never acts.

The gap worth building for

That correlation and exception layer, not signature capture, is where claims teams lose days of adjuster time. Claims operations also sits inside the broader back-office automation space Major covers at AI agents for business.

The stronger build here is not replacing Guidewire's native integration or DocuSign's signing UI. It is operating the lifecycle around them: correlating activities to envelopes, keeping a durable ledger of who has signed, and giving an adjuster one place to see exceptions before a claim moves toward payment.

The systems, APIs and decision points

Guidewire ClaimCenter: activity endpoints

ClaimCenter Cloud exposes claim and activity data through its Cloud API, with REST resources under /rest/claim/v1 and /rest/common/v1. The activity endpoints that matter are:

  • GET /common/v1/activities returns activities the caller can see under ACL (access control list) rules.
  • GET /common/v1/activities/{activityId} returns one activity.
  • GET /claim/v1/claims/{claimId}/activities returns the activities on a specific claim.

The activity query documentation shows you can scope returned fields with ?fields=id,subject and filter by assignedUser or assignedUsername. Activity records carry an activity pattern, a subject, an assigned user and a status (code and name), enough to identify "signature required" activities without pulling the whole claim file.

Guidewire ClaimCenter: authentication and the webhook gotcha

Authentication runs on OAuth 2.0. For a service integration, Guidewire documents the client-credentials flow through Guidewire Hub, where a service account is mapped to ClaimCenter roles and permissions rather than impersonating a named user.

The gotcha: these Cloud API pages do not describe a native outbound webhook for activity changes. Event-driven updates typically run through Guidewire's internal plugin or messaging framework, not a public webhook you can subscribe to from outside the tenant.

So a scheduled poll against the activities endpoint is the dependable path. Rate limits for this API are not published on Guidewire's public pages, so plan conservatively.

DocuSign: envelopes and Connect

The Envelopes resource in the eSignature REST API creates, sends and retrieves envelopes and their recipients. It is authenticated with an OAuth 2.0 bearer token using either the authorization-code or JWT grant.

For status updates, DocuSign Connect is the webhook mechanism. An account administrator registers a Connect configuration pointing at a publicly reachable HTTPS endpoint, and DocuSign then pushes envelope and recipient event notifications as they happen, in JSON or XML.

DocuSign: rate limits

DocuSign's Rules and Limits page sets firm caps:

  • Status-check polling on a single envelope is capped at once every 15 minutes.
  • If you do poll, DocuSign recommends 20-minute intervals.
  • Account-wide, the default hourly cap is 3,000 calls.
  • Production accounts get a 500-call burst allowance in 30 seconds.
  • DocuSign recommends keeping envelope creation and updates to five or fewer API calls per envelope.

Build for Connect first and treat polling as a fallback.

Regulatory context

Automation touching claim settlement falls under state Unfair Claims Settlement Practices Acts, modeled on NAIC Model #900. These require insurers to document the basis for a claim decision and to not let automation bypass required manual review of adverse or payment decisions.

The NAIC Model Bulletin on AI Systems adds that insurers using AI in claims need a written governance program and the ability to explain how an AI-assisted decision was made.

A completed DocuSign envelope is evidence that a document was signed, not authorization to release payment. The system has to keep that distinction explicit rather than buried in code nobody reviews.

Split the workflow across app, agent and automation

Architecture diagram showing Guidewire ClaimCenter and DocuSign connectors feeding a claim signature ledger app, with an agent resolving unmatched events before an adjuster approval gate

Claim signature tracking: app, agent, and workflow split

Keeping the three layers separate is what makes the system auditable.

The app: a claim-envelope ledger

The app is the system of record for this process. It stores which ClaimCenter activity is waiting on which DocuSign envelope, who the required signers are, each signer's status and the full history of events received.

ClaimCenter tracks claims, not envelope internals, and DocuSign tracks envelopes, not claims. This state lives in the app's managed database, which is also what makes a stuck signature debuggable six weeks later.

The workflow: repeatable, deterministic steps

The workflow polls or receives the ClaimCenter activity, calls the DocuSign Envelopes API to send the document, receives and verifies the Connect event, updates the ledger and writes the status back to the ClaimCenter activity. None of these steps require judgment, which is exactly what you want for something a regulator might ask you to reconstruct.

The agent: reasoning on mismatches only

When a Connect event arrives with an envelope ID that does not cleanly match an open ledger entry (a duplicate envelope, a renamed document, a split claim), the agent reviews the claim and activity context. It proposes a match or flags the event as unresolved, and drafts a one-paragraph note for the adjuster instead of raw event logs.

A person approves its proposals in the app; the agent never updates payment readiness itself.

Diagram showing the envelope status event path from a DocuSign Connect notification through claim correlation to a human payment-readiness review gate

Envelope status event path from send to approval gate

Automate claim document signing Guidewire workflows on Major

  1. Connect both systems as custom API connectors, because Major does not list an official Guidewire ClaimCenter or DocuSign connector in its current catalog: for ClaimCenter, use the tenant's Cloud API base URL and configure the OAuth 2.0 client-credentials flow against Guidewire Hub, with the service account scoped to read activities and claims and write activity updates; for DocuSign, configure OAuth 2.0 with your integration key and the scopes needed to create and send envelopes, and store both credentials in Major's credential proxy, scoped to this app, never hardcoded. You should see both connectors listed as authenticated for this app, with no credentials visible in any workflow step.
  2. Build the data model with four tables: a claims table (claim ID, claim number, status, assigned adjuster), an envelopes table (envelope ID, ClaimCenter activity ID, claim ID, document type, sent date, current status, last event timestamp), a signers table (envelope ID, recipient ID, role, name, signed status) so you can tell which of three required co-insureds has not acted, and an event log table that appends every DocuSign Connect notification with its raw payload and a processed flag, your idempotency guard and audit trail in one place. You should see four empty tables whose columns line up with the fields above, ready to receive claims and events.
  3. Build the app by describing it to Major using the first example prompt below. You should see a dashboard with one row per claim showing ClaimCenter activity status, DocuSign envelope status and signer checkboxes, plus a separate queue for unmatched events.
  4. Add the agent using the second example prompt below, limiting it to matching unmatched Connect events and drafting adjuster notes. You should see the agent attached to the unmatched-event queue, producing proposed matches or "unresolved" flags with a short reasoning note, and no write access to claim state.
  5. Set the workflow trigger with two paths: the primary path is an authenticated webhook endpoint that receives DocuSign Connect notifications in near real time, and the secondary path is a scheduled poll every 20 to 30 minutes, respecting DocuSign's per-envelope limits, against the claim activities endpoint for new "signature required" activities that still need an envelope sent. You should see Connect events landing in the event log within moments of a signer acting, and new signature activities picked up on the next scheduled poll.
  6. Test the failure paths before real claims flow through: redeliver a "completed" Connect event to confirm the processed flag blocks a second ClaimCenter update, send an envelope with an unknown claim reference to confirm it lands in the agent's queue, decline or void a test envelope to confirm the claim is flagged for the adjuster, and misconfigure the fields parameter on a poll to confirm the workflow flags the gap instead of reading it as "no activity." You should see each test case produce a flag, a queued proposal or a blocked duplicate, and never a silent status change.
  7. Roll out with a human in the loop at two points: before an envelope goes out, route any ambiguous required signer list (a late-added co-insured, a changed beneficiary) to the adjuster for confirmation, and before payment readiness changes in ClaimCenter, require an adjuster to review the completed signer checklist and click approve, so the app writes the activity closure and readiness flag only after that click and never automatically on receipt of the last Connect event; teams can see that approval screen by starting a build on Major. You should see adjusters and supervisors with an approve button, compliance and audit with view-only access, and ClaimCenter activities that close only after a recorded human approval.
"Build an app that tracks claim settlement documents awaiting signature. It should show one row per claim with the activity status in ClaimCenter, the DocuSign envelope status, and a per-signer checklist. Flag any envelope with no status change in more than 5 business days. Give adjusters a button to approve payment readiness once all signers are complete, and a queue for unmatched DocuSign events that need review."
"When a DocuSign Connect event arrives that doesn't match an open envelope record by ID, look at the claim number and signer names in the event payload, compare against open claims in the ledger, and either propose the matching claim and activity with your reasoning, or mark it unresolved for manual lookup. Draft a two-sentence note for the adjuster summarizing what happened. Never change payment readiness or claim status yourself."

Governance and IT control

This process touches claim settlement documents and policyholder personal information, so three controls carry most of the weight:

  • SSO gates who can open the claim-signature app, tied to the identity provider claims operations already uses.
  • Role-based access limits who can approve payment readiness (adjusters and their supervisors) versus who can only view status (compliance, audit).
  • An audit log records every write the workflow or agent makes, from sending an envelope to updating a ClaimCenter activity.

Each audit entry carries a timestamp, the triggering event, and whether a person or the agent made the call. That maps directly to the NAIC Model Bulletin's requirement to explain AI-assisted decisions on request.

Scoped credentials

Credentials for both systems are held in Major's credential proxy and scoped narrowly. On the Guidewire side, that means read and write access to claim activities and documents; on the DocuSign side, envelope create, send and retrieve.

Storage and versioned deploys

The managed database and file storage keep claim-envelope state and event history retained and backed up at the platform layer, not scattered across inbox rules or a spreadsheet.

Deploys of the app, agent and workflow are versioned. A change to the matching logic or the approval screen can be reviewed and rolled back like any other production change, which is the control a compliance reviewer will ask to see.

Failure handling and edge cases

API and data failures

  • API errors and rate limits: both ClaimCenter and DocuSign calls need retry logic with exponential backoff. DocuSign's hourly and burst caps will throttle bursts of calls, so respect the 15-minute polling minimum and prefer Connect events.
  • Duplicate or out-of-order events: DocuSign Connect can redeliver notifications. The processed flag, keyed on envelope ID plus event timestamp, keeps a redelivered "completed" event from double-triggering a ClaimCenter update.
  • Stale or partial data: if a ClaimCenter poll returns incomplete activity data (a known risk if the fields parameter is misconfigured), the workflow should flag the gap rather than treat missing fields as "no activity."

Outcome and judgment failures

  • Declined, voided or expired envelopes: these are outcomes, not failures to retry around, so flag the claim for adjuster attention immediately rather than leaving it "waiting" indefinitely.
  • Unmatched events: when an envelope's claim reference is missing or a duplicate claim number exists, the agent proposes a match for a person to confirm. An unresolved match should block, not default to "closest guess."
  • What the agent must never do: change a ClaimCenter activity's status, mark a claim payment-ready, or close out a signature requirement without a human click. The agent's output is always a proposal or a note, never a committed action on claim state.

What to measure

  • Time from activity creation to envelope sent, and from envelope sent to fully executed.
  • Count of envelopes overdue (no signer action past a set threshold) at any given time.
  • Number of unmatched or ambiguous Connect events requiring manual resolution per week.
  • Retry and backoff counts against each API, as an early signal of integration health.
  • Manual exception rate: the share of claims that need an adjuster to step outside the standard flow.

Track these from week one so you have a real baseline instead of a guess.

Before you go live

  • [ ] Confirm the ClaimCenter service account uses the client-credentials flow through Guidewire Hub and is scoped only to read activities and claims and write activity updates.
  • [ ] Confirm a DocuSign account administrator has registered the Connect configuration against your public HTTPS webhook endpoint.
  • [ ] Set any fallback polling to 20 to 30 minutes so no single envelope is checked more often than every 15 minutes.
  • [ ] Verify the event log's processed flag, keyed on envelope ID plus event timestamp, blocks a redelivered "completed" event.
  • [ ] Test that declined, voided and expired envelopes flag the claim for the adjuster instead of staying in "waiting."
  • [ ] Confirm the agent has no permission to change activity status, payment readiness or signature requirements.
  • [ ] Verify that payment readiness and activity closure write to ClaimCenter only after an adjuster's approval click, and that the audit log records who made each call.
  • [ ] Assign roles so only adjusters and supervisors can approve, while compliance and audit get view-only access.

Start building on Major

Build a claim-signature tracking app that keeps Guidewire activities, DocuSign envelope events, and adjuster approvals in one governed operational view.

Related articles

About the author

Ritvij Gautam is Head of Growth at Major.

Last reviewed November 6, 2026 by Ritvij Gautam.

Frequently asked questions

Can Guidewire ClaimCenter integrate with DocuSign?
Yes. Guidewire's Marketplace lists a DocuSign integration for ClaimCenter that lets adjusters collect, track, and store electronic signatures natively, and Guidewire and DocuSign have jointly announced the offering for ClaimCenter and PolicyCenter. That native listing differs from a custom Major build, which focuses on correlating envelope status to specific claim activities, keeping durable event history, and routing exceptions for adjuster review rather than on the signing experience itself.
How should ClaimCenter detect a completed DocuSign envelope?
DocuSign Connect, not polling, is the documented path: you register a Connect configuration against a publicly reachable HTTPS endpoint and DocuSign pushes envelope and recipient status events as they occur. The receiving system should verify each event and process it idempotently, keyed on envelope ID and event timestamp, before writing any update back to the matching ClaimCenter activity.
Should an automated signature workflow release claim payment?
No. A completed DocuSign envelope confirms a document was signed, not that payment is authorized. State Unfair Claims Settlement Practices Acts require documented, reviewable claim decisions, so payment readiness should move to adjuster review once all required signers complete, with an authorized person or the policy's payment system making the final release.
What API access is needed for ClaimCenter and DocuSign?
Both use OAuth 2.0 bearer tokens. ClaimCenter Cloud API supports a client-credentials flow through Guidewire Hub for service integrations, with a service account mapped to ClaimCenter roles. DocuSign's eSignature API uses an authorization-code or JWT OAuth grant tied to an integration key and a DocuSign account. Consult each vendor's official developer documentation for tenant-specific scopes and permissions before building.