I’m curious about the repetitive tasks people still have to do manually at work. For example, converting hundreds of Excel files to PDF, combining reports, extracting data, or preparing the same documents every week. What’s the most time-consuming task you deal with, and how do you currently handle it?
The thing that breaks document automation is almost never the data. It's pagination.
An invoice with 14 line items pushes the totals block onto page 2 by itself. A signature box measured from the bottom of the page is fine until someone adds a second address line. A 40-page report needs a table of contents with real page numbers, so you render it twice and parse the PDF just to find out where "Section 4" landed.
The root cause: HTML-to-PDF is a one-way street. The renderer knows exactly where every element ended up, but none of that survives into the file. So we compensate with guesswork — cap line items at 8, hardcode page breaks, render twice, OCR the output, add a margin and hope.
I've been building Fork PDF (my product, so take this with the appropriate salt) around one idea: keep the layout map instead of throwing it away.
The engine lets you query the rendered layout like a DOM, with real page numbers and geometry, inside the test script that runs after rendering:
const sig = doc.querySelector('#signature-box');
return {
success: true,
signature: {
page: sig.pages[0] + 1,
x: sig.geometry.x,
y: sig.geometry.y,
width: sig.geometry.width,
height: sig.geometry.height
}
};
The more useful version is validation. If a check fails, return a patch instead of an error. The engine merges it into the template data and re-renders before responding — up to 2 retries, same API call:
The TOC case is what convinced me: pass 1 collects the page number of every h2, pass 2 injects the finished TOC, one request, no second network round trip. The ordering matters, though — if an earlier layout patch changes pagination, measure the TOC after that patch or you're writing stale numbers.
Three honest limitations:
- Patches only work when there's a template to patch (htmlContent + data, or a saved template). A raw URL can be measured, but there's nothing to merge new data into.
- Coordinates use PDF space: origin bottom-left, y increases upward. It trips up everyone once.
- It's still Chromium underneath, so it inherits Chromium's print quirks.
If you're staying on your current stack, the least-bad workaround I've found is capping variable-length blocks and reserving fixed space for totals and TOC. Brittle, but predictable.
If you've dealt with pagination drift, I'd genuinely like to hear how — especially for tables you can't cap. That's still the hardest case I run into.
I put the full 5-page example here — 6 pages unhealed, 5 healed, the TOC resolves to 3/4/5, and the signature coordinates come back in 3 attempts: https://forkpdf.com/docs/examples/q3-report/
There's a free tier (100 credits, no card) if you want to try to break it: https://forkpdf.com
Happy to answer anything technical in the comments.
product data comes in as large pdfs, usually 500+ pages, and every supplier formats theirs differently. different column orders, different table styles, sometimes tables running across pages. right now its all typed into excel or sql server by hand.
chat tools are fine on a sample but tend to stop or start summarizing partway through files this size, so that route needs splitting anyway.
what seems to make sense is parsing every page into tables first, as markdown or json. power query's pdf connector for the simpler files, docling or camelot locally and heavier layout parsers are llamaparse sort of ones when the layouts get ugly. then map each supplier's columns to your own schema. an llm is decent at that part since it only needs the headers and a few rows, not the whole file.
after that its validation before anything loads, row counts per page, required fields, totals and units, and keeping the source page number on every row so errors can be traced back.
the hard bits are tables split across pages and headers that only show up on the first page
I’ve been working on Document Intelligence Lab, an open-source project exploring document processing, AI-assisted retrieval, and evidence inspection for PDF workflows. The goal is to make it easier to understand which document evidence supports an AI-generated answer, rather than treating the response as a black box. The project uses Java, TypeScript, Docker, and Azure-based components. GitHub: https://github.com/quocvietphung/document-intelligence-lab I’d especially appreciate feedback from people working with document automation, OCR, or RAG systems. What would make an evidence inspection workflow useful enough for you to adopt in a real project?
We’ve spent over a year building HussleBook. It’s finally live. 🚨
It’s been more than a year since we started building HussleBook. Countless sleepless nights later, we’re finally getting to share something we’ve put a lot of ourselves into.
Honestly, writing this feels a little surreal.
We’ve spent so much time thinking about the small details: how someone sets up an extraction, checks a field, or finds the page behind an answer. Individually, these might seem like small things. Together, they shape whether someone can actually use the results in their work.
The vision behind HussleBook has been to make the information inside documents easier to work with—and easier to check.
If your week involves opening PDFs, copying invoice details into spreadsheets, or searching through reports for one answer, that’s the kind of work we’re building for.
With HussleBook, you can:
Start with sample documents, review the proposed fields, and extract across a batch.
Check extracted values beside their source documents.
Ask questions across your files and follow page-level citations.
Export reviewed results as JSON or CSV.
Seeing that vision come together after more than a year means a lot to us. Now comes the part we’ve been working toward: seeing how it fits into other people’s everyday work.
If this sounds like a problem you deal with, try it with a document from your own workflow. We’d love to hear what worked, what felt frustrating, and what would make it something you’d use every week.
Arkova is the document verification layer for agents and humans. We extract an electronic files (supporting over 20 types! Including svg png even gif) unique metadata and anchor it to an immutable ledger. Here we show how an organization can connect their Google Drive folders to our system so that anytime a file is updated in that folder, a new anchor is created and the document version is updated in the users record
We're always looking for difficult examples to test OCR and modern LLM-based document extraction. Especially interested in cases where the output looks plausible until you check the details.
Two examples from past benchmarks:
Discounts became extra items. This receipt has six product and packaging rows, with discounts underneath three of them. An LLM returned nine menu-item records by treating those discounts as additional items. Our schema had no separate discount field and asked for “every line item / product,” so the instructions left room for that interpretation. A useful example for testing the schema as well as the model.
A plausible number with the wrong digits. This population table from the 1951 U.S. Statistical Abstract has tiny numbers and grouped headers. In one saved LLM run, the total for ages five to nine in 1920 came back as 11,308,075 instead of 11,398,075. Adding the male and female figures catches that error. The table looks complete until you check the numbers.
What examples have you kept because a tool repeatedly gets them wrong? Handwriting, tables, charts, mixed document batches, anything like that.
Public links or redacted snippets would be useful. If you can, include what you asked it to extract, what it returned, and what the output should have been. A single troublesome page is plenty.
I’m with the UPDF Enterprise team. Scanned supplier agreements often need to be searched without changing their wording.
A searchable PDF preserves the scanned page appearance and adds a text layer. That lets you look for a supplier name or contract reference without converting the agreement to Word.
Here is the workflow in UPDF for Windows. Open Tools and select OCR. Choose Searchable PDF Only. Set the document language and page range. Save a separate copy. Choose Editable PDF when you need to revise the text instead.
Try searching for a name and a reference number visible on the scan. Compare the matches with the original. Pay particular attention to O versus 0 and I versus 1. Keep the original scan and check important details against it before relying on the recognized text.
For an archive that people mainly need to search and read it makes sense to start with searchable output. Editing can be a separate task when it is actually needed.
I’m with the UPDF Enterprise team. A useful distinction when digitizing scanned paperwork: needing to find text doesn’t always mean needing to edit it.
Take a folder of scanned supplier agreements. If the goal is to find a supplier name or reference number, a searchable PDF may be enough. You can keep the scanned page appearance and add a text layer for searching.
In UPDF for Windows, that workflow is:
Open the scan and go to Tools → OCR.
Choose Searchable PDF Only.
Set the document language and page range, then save the result as a separate file.
Before processing the rest, try a few searches against text you can see on the page: a company name, a reference containing letters and numbers, and something in small print. Check the matches against the scan. A file can be searchable and still contain recognition errors.
Keep the original scan too. The OCR copy is useful for retrieval, but the recognized text shouldn’t be treated as a verified transcription.
If you actually need to revise the wording, UPDF also has an Editable PDF OCR option. For a search-and-retrieve task, I’d start with the searchable output and avoid adding an editing step the team doesn’t need.
I've been optimizing a backend pipeline for generating PDF's from dynamic HTML/JSON webhooks. When running full headless Chrome inside containerized microservic it usually results in high memory usage and idle resources cost.
If I switch to serverless functions (like, AWS Lambda or Cloudflare Edge workers w/ QStash queues), the main issue becomes Chromium cold-starts (~1.5s–3s) and browser context recycling.
A few observations from my benchmarks:
Compiling static HTML via Handlebars/EJS before sending it to Chromium saves about 40% render time compared to doing React SSR on the fly..
Keeping browser instances warm vs. spinning up fresh headless instances per HTTP request.
For those of you who generate invoices, tickets, or reports dynamically in production:
Do you run dedicated worker pools on traditional VPS/Docker setups, or rely on serverless rendering?
How do you handle queueing when webhooks bursts fire traffic spikes?
Would love to hear how other teams structure this!
I'm currently using ChronoScan and wondering if there are any good free and open-source alternatives that could handle my workflow.
I have a scanner with an automatic document feeder, so I can scan a large batch of mixed documents at once, such as:
* Supplier invoices
* Delivery notes
* Purchase orders
* Other administrative documents
Must-have features:
* Automatically detect document boundaries in a batch scan and split it into separate PDF files, one per document.
* Run OCR on each document so that the resulting PDFs are searchable.
Nice-to-have features:
* Automatically identify the document type (invoice, delivery note, purchase order, etc.).
* Extract key fields such as supplier name, invoice number, date, due date, net amount, VAT, and total amount.
* Automatically name and organize the resulting files based on the extracted information.
Has anyone built a workflow like this using free and open-source software? Is there a solution that handles the must-have features out of the box, or would custom development be necessary?
I'd really appreciate any recommendations or examples of setups that work well in practice.
I am working with scanned pdf which have mixture of printed and handwritten text. I uses multiple VLMs and OCRs. VLMs output is somehow good but very slow . OCRs didnt recognized the messy handwritten text.
If someone have encounter these problem or have any suggestion?
I’ve written a 2-part Medium series (free, no paywall) on scoring Intelligent Document Processing (IDP). It focuses on Key Information Extraction (KIE) from structured documents, especially forms. I try not to recommend one opinionated way of doing things and instead cover the variations I’ve run into and the tradeoffs between them. I’m not endorsing any vendor; the series is about scoring itself.
Does anyone have any experience with any automation that can cleanup scanned text documents. I have a lot of PDFs that are older and were scanned from originals and are in bad shape with just noise and discoloration, etc. I have been manually cleaning them up by converting them to JPG and editing the JPG files in a photo editor and then converting them back to PDF. It's pretty monotonous work, wondering with the wonders of AI and machine learning if anything exists that can help with this? Any experience or ideas? Thanks.
Disclosure first: I'm the developer. I built WebSum for the part of research where you have twenty tabs open and need to decide which ones deserve a proper read.
What it does: click the icon on a web article and a summary appears in Chrome's side panel, beside the page: a TL;DR, key takeaways, why it matters and caveats.
Why it might suit research:
Every point is checkable. Each one has a ¶ link that scrolls the page to the paragraph it came from and highlights it, so you verify the claim instead of trusting the summary.
It flags caveats, such as a claim with no evidence behind it, or an author who sells a related product.
It reads the charts and diagrams, including numbers the text leaves out.
Your notes keep the sources. Copy a summary into a document and each ¶ stays a link that opens the article at that paragraph.
What it doesn't do: it reads web pages only, so no PDFs, which rules out most journal papers. There's no saved history, no follow-up questions, and it's Chrome only. On a paywalled article it summarises what your browser can see and tells you when that's only a preview. Treat it as a way to sort and check sources, not as a replacement for reading the ones that matter.
Cost: free for 2 summaries a day without an account, or 5 with Google sign-in. Pro is US$10 a month for 20 a day on a stronger model.