PDF Converter
Let people turn the files they upload into PDFs, and PDFs back into editable formats.
What it adds
A conversion service that accepts an uploaded document and returns it in a requested format, with progress and a downloadable result.
What your agent is told to do
5
What your agent is told to do
5-
1
Start from the app's existing upload path rather than adding a second one. If File Upload, Upload Malware Scanning, or Secure File Downloads already exist, the converter consumes what upload produces and hands its output to the existing download route, so permissions and scanning are inherited rather than reimplemented.
-
2
Decide the conversion pairs you will actually support and list them in the interface. A short honest list of office documents, images, and PDF to text beats a control that offers every combination and fails on most of them.
-
3
Enforce file size, page count, and accepted types on the server before any conversion starts. A limit checked after the file has been parsed has already cost you the memory and the CPU you were trying to protect.
-
4
Run every conversion in the app's existing background job system and show the user a progress state with a cancel control, rather than holding an HTTP request open until the work finishes.
-
5
Do not build a general-purpose document engine or attempt to preserve every layout feature. Convert the common cases faithfully, and tell the user plainly which parts of the original did not survive.
Edge cases it handles
8
Edge cases it handles
8- Size and page-count limits must be checked before conversion begins, not after. A two-thousand-page document rejected at the end has already consumed the worker that other users were queued behind.
- A synchronous conversion will time out on anything real. Queue the work, return immediately with a job the user can watch, and let the result appear when it is ready rather than blocking the request.
- Fonts, embedded images, and page breaks all drift during conversion. Preserve them where you can, and when fidelity is lost say so on the result screen instead of handing back a mangled file with no explanation.
- Password-protected sources cannot be opened without the password, and corrupt files will crash the parser. Both must fail as a single item with a clear reason, leaving the rest of a multi-file batch to finish.
- Converted output and the original upload both linger on disk. Set a retention window, delete intermediate artefacts on a schedule, and make the expiry visible so a conversion tool does not quietly become a document archive nobody audited.
- The download link for a converted file must check the same permissions as the source. A guessable result URL turns every conversion into a public copy of a private document.
- The same file converted twice should not be converted twice. Key the job on the file contents and the target format so a user clicking again gets the existing result.
- A conversion that produces a zero-byte or unreadable output must be reported as a failure. Do not let an empty file through as a success because the process exited cleanly.
Definition of done
9
Definition of done
9- Size, page count, and file type are rejected server-side before any conversion work starts.
- Conversions run in the background with visible progress and a working cancel.
- Password-protected and corrupt files fail individually with a readable reason, and the rest of the batch completes.
- Fidelity loss is reported on the result rather than left for the user to discover.
- Source files and intermediate artefacts are deleted on a stated schedule.
- Downloading a converted file enforces the same access rules as the original upload.
- The converter reuses the app's existing upload, scanning, and download paths rather than a parallel set.
- The feature matches the existing design system.
- No existing functionality is broken.
Related features
Fillable PDF Forms
Fillable PDF Forms
Let people fill in a PDF form on screen and download the completed copy.
What it does
An on-screen fill layer over a PDF form that writes the entered values back into a downloadable file.
How it works
- 1 Render the document and place editable inputs over its real form fields, so the user types on the page they recognise rather than into a separate form beside it.
- 2 Extend the app's existing PDF Export and document viewing paths rather than introducing a second renderer. Two renderers will disagree about fonts and page size, and the user will see the difference between screen and download.
- 3 Save progress as the user types using the app's existing Autosave, and restore the partly filled form on return.
Copy the prompt
No account needed
Add this feature to my app:
https://addthisfeature.com/x/fillable-pdf-forms
Document Scanner
Document Scanner
Turn a phone photo of a paper document into a straight, readable, multi-page file.
What it does
A camera capture flow that detects page edges, corrects perspective, and assembles the shots into one document.
How it works
- 1 Lead with the capture screen: live edge detection, a shutter, and a running strip of the pages already taken. Somebody should be able to shoot five pages without leaving the camera.
- 2 Correct perspective and crop to the detected page before saving, then apply a contrast pass so a grey photo of a page reads as black text on white.
- 3 Give the user a review step where pages can be reordered, retaken, or deleted before anything is committed.
Copy the prompt
No account needed
Add this feature to my app:
https://addthisfeature.com/x/document-scanner
Document Import
Document Import
Turn an uploaded document into editable content instead of a dead attachment.
What it does
An import path that converts an uploaded word-processor or rich-text document into the app's own editable content.
How it works
- 1 Start from the app's existing File Upload rather than opening a second route with looser rules. A file that is about to be parsed and rendered back as editable content needs the size ceiling and the malware scan more than an ordinary attachment does, not less.
- 2 Map the imported document onto the content model the app's editor already uses. Anything the editor cannot represent must be dropped deliberately and reported, not smuggled in as raw markup.
- 3 Run parsing as background work with a visible status, because a large document will exceed a request timeout and the user needs to know whether it is working or stuck.
Copy the prompt
No account needed
Add this feature to my app:
https://addthisfeature.com/x/document-import
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.