DocuSign Signature Request
Send documents for signature through DocuSign and track every recipient's state.
What it adds
An envelope-based signing flow that sends app documents to DocuSign, mirrors recipient and envelope status, and stores the completed files.
What your agent is told to do
5
What your agent is told to do
5-
1
Model the request in the app first: the document, the ordered recipients with their roles, and the envelope's own lifecycle state, so the app can answer where a signature stands without calling the provider.
-
2
Prefer a configured template with named roles and named fields over positioning signature fields at fixed coordinates. Coordinates break the moment the document's layout or page count changes, and they break silently.
-
3
Store the envelope identifier against the app record when the send is confirmed, and make sending idempotent on that record so a retry after a timeout resumes tracking rather than sending the customer a second copy.
-
4
Verify every status callback's authenticity before acting on it, ignore callbacks for envelopes the app does not recognise, and treat repeated deliveries of the same status as one event because the provider will retry.
-
5
Store completed documents and their audit certificates in the app's existing file storage behind the same permission checks as the record they belong to, and serve them through short-lived links rather than a permanent public URL.
Edge cases it handles
8
Edge cases it handles
8- Recipients need roles, an explicit routing order, and any required identity verification set before the envelope is sent. Getting the order wrong sends the document to a counter-signer before the person whose signature it depends on.
- Templates change. Role names and field names must be resolved against the current template and the send refused with a clear error when a role no longer exists, rather than sending an envelope with an unassigned signer.
- Callbacks are unauthenticated until proven otherwise and arrive more than once, out of order, and sometimes long after the fact. Verify the signature, key on the envelope and event, and ignore a status older than the one already recorded.
- Envelopes end in states other than completed: declined, voided, expired, and corrected all need a represented state in the app and a defined effect on whatever the signature was gating.
- Signed documents and audit trails are among the most sensitive files the app holds. They must inherit the record's permissions, not be reachable by anyone with a link, and any temporary link must expire.
- The provider will rate-limit and will occasionally be unavailable. Queue the send, back off, and show the user that the request is pending rather than reporting a signature request that was never actually created.
- The stored authorization expires and must be refreshed before it lapses. A refresh failure should mark the connection as needing reconnection and pause sends, not fail each envelope individually with an unhelpful error.
- If callbacks stop arriving, envelopes will sit at a stale status forever. Reconcile open envelopes on a schedule so status is eventually correct even when a webhook was lost.
Definition of done
9
Definition of done
9- The app holds its own record of the envelope, its recipients, and their states, readable without contacting the provider.
- Signature placement uses templates with named roles and fields rather than fixed coordinates.
- Sending is idempotent per record, so a retry after a timeout never produces a second envelope.
- Status callbacks are authenticity-verified, deduplicated, and safe to receive out of order.
- Declined, voided, expired, corrected, and completed envelopes each have a represented state and a defined consequence.
- Completed documents and audit certificates are permission-checked and served through expiring links.
- A scheduled reconciliation corrects any envelope whose callback was lost.
- The feature matches the existing design system.
- No existing functionality is broken.
Related features
Contentful Entry Sync
Contentful Entry Sync
Create and update Contentful entries against the connected space, environment, and locale.
What it does
A sync that writes app records into Contentful entries using the connected space's content model and locale configuration.
How it works
- 1 Have the operator select the space, the environment, and the default locale during connection, and store all three, because writing production content into a sandbox environment is an easy and expensive mistake.
- 2 Fetch the content model at connection time and again before each sync run, map app fields to entry fields by their stable identifiers, and validate the value type against the model before attempting the write.
- 3 Write every localized field under an explicit locale rather than relying on whatever the space treats as default, and state clearly which locales the app owns and which it leaves to editors.
Copy the prompt
No account needed
Add this feature to my app:
https://addthisfeature.com/x/contentful-entry-sync
Typesense Index Sync
Typesense Index Sync
Keep a search index in step with your records so results stay current and correctly scoped.
What it does
A one-way sync from the app's records into a Typesense collection, with server-enforced tenant filtering and a rebuild path.
How it works
- 1 Identify every model users search today and declare the indexed shape explicitly: the fields people type into, the fields they filter and sort on, and nothing more. Treat a missing or newly added field as absent rather than letting the document fail validation.
- 2 Reuse the app's existing background-job system to push creates, updates, and deletes. Do not index inside the request cycle; a slow or unreachable search service must never make a save fail or hang.
- 3 Build the tenant, workspace, and permission filter on the server at query time and attach it to every search. Do not accept a filter, collection name, or scope value from a client-supplied parameter, because anything the browser can set the browser can change.
Copy the prompt
No account needed
Add this feature to my app:
https://addthisfeature.com/x/typesense-index-sync
Algolia Index Sync
Algolia Index Sync
Keep the search index matching the database, including who is allowed to see what.
What it does
A sync pipeline that mirrors records into a search index with tenant-scoped filters and scheduled reconciliation.
How it works
- 1 Identify every record type that should be searchable and define one index document per record, keyed by an identifier that never changes for the life of that record.
- 2 Push changes through the app's existing background-job system on create, update, and delete, and make every write idempotent so a replayed job produces the same document rather than a duplicate.
- 3 Put tenant, workspace, and visibility values on each document as filter attributes, and have the server issue short-lived scoped search credentials that pin those filters. The browser must never choose its own filter.
Copy the prompt
No account needed
Add this feature to my app:
https://addthisfeature.com/x/algolia-index-sync
How it works
-
1
Copy the link
Grab the Markdown instruction URL for this feature.
-
2
Give it to your AI
Paste it into Claude Code, Cursor, v0, Lovable — whatever you build with.
-
3
It inspects, then implements
Your agent reads your existing app first, then adds the feature to fit it.
Works with your stack
These instructions are written to adapt. They tell the agent to detect your framework, match your existing design system, and reuse what you already have — rather than assuming a particular stack.
Need it tighter than that? Customize the feature and tell it exactly what you're running.