Sluice: Every Document, One Way In

Posted: 2026 | Category: Document Ingestion

The Tuesday Where Nothing Arrives Twice

Someone walks to the Konica in the hallway, drops a stack of invoices in the feeder, and presses the green button. The scanner emails a 60-page PDF to a shared mailbox. That mailbox is watched by a colleague who is on holiday.

Meanwhile a supplier sends a delivery note as a photo taken at an angle. A client uploads a contract through your website. A partner pushes a batch over SFTP at 03:00 because that is when their nightly job runs. Your accountant forwards six PDFs with the subject line “fyi”.

All of it is the same thing: a document from the outside world that needs to be read, understood, and put somewhere. And all of it arrives through a different door, gets handled by a different person, and lands in a different folder.

The documents are not the problem. The doors are.

A cluttered office mail room where someone loads a thick stack of invoices into the feeder of a floor-standing scanner Every sender picks a different door. What happens behind them should be identical.

The Ingestion Layer Nobody Wants to Build

Every backoffice eventually builds this. Badly, and twice.

You start with an inbox rule. Then someone needs a scan-to-folder share. Then a customer wants an API. Then the mailbox fills up and a document from March turns out never to have been processed, and nobody can prove whether it arrived at all.

The parts are all boring and all mandatory:

  • Accept a file from whichever protocol the sender happens to use
  • Keep the original, exactly as received, forever
  • Turn a scan into text without losing the layout
  • Work out what kind of document it is
  • Pull the fields out of it
  • Let a human check the ones the machine is unsure about
  • Push the result into the system that actually needs it

Nobody gets promoted for building that. Everybody needs it.

How We Glued It Shut

Sluice is that layer, as a product. Documents come in through many protocols, converge onto one pipeline, and leave as structured data delivered wherever you want it.

One way in. Every channel funnels through a single function. A webhook push, a browser upload, an SFTP drop, an FTP drop, a scan-to-email straight off the office printer, an inbound mail address, a polled Gmail, Outlook or IMAP mailbox. Same pipeline, same audit trail, same behaviour.

The original is kept, always. Before anything touches a document, the raw bytes are written to content-addressed object storage under a dated path and never overwritten. OCR output, thumbnails and extracted JSON live separately, as derived artifacts. If you ever need to prove what a supplier actually sent you, the answer is one click away, byte for byte.

Your taxonomy, not ours. A workspace defines its own document types: a name, a few classification hints, and a field schema. The classification prompt is generated from that registry. There is no built-in list of document types you have to bend your business around. An invoice for a notary and an invoice for a dealership are not the same document, and Sluice does not pretend otherwise.

Batch scans get split. Drop a 60-page stack and the splitter works out where one document ends and the next begins, then shows you the page boundaries so you can correct them before anything is filed. If the analysis fails, the document is processed as one. The pipeline never blocks on it.

Extraction against a schema. Each document type carries its own field schema: strings, numbers, dates, booleans, enums. Required fields that come back empty block auto-approval instead of quietly passing through as null.

A review inbox for the uncertain ones. Everything lands in one queue with the document preview next to the extracted fields. Approve, edit, reject or reprocess. Set a confidence threshold and the clean ones approve themselves.

Delivery is part of the product. On approval, the result goes out to the sinks bound to that document type: an HMAC-signed webhook, an email, a drop onto a remote SFTP folder, or a push into an S3 bucket. You choose whether the sink receives the file, a JSON sidecar with the extracted data, or both. Every attempt is logged and retryable. There is also CSV, XLSX and JSON export.

It stays up. The pipeline runs durably through Temporal with retry policies, and falls back to inline processing when Temporal is unavailable. Ingest never slows down because a worker is having a bad day.

never overwrittenagainst your own typesauto or by a personWebhookBrowser uploadSFTP / FTPScan to emailInbound addressPolled mailboxOne way inOriginal stored,never overwrittenOCRClassifyExtractReview inboxDeliver: webhook,email, SFTP, S3,export
Six ways in, one pipeline, and delivery to whatever system asked for the result.

What Makes This Different

There is an established category here: Parseur, Mailparser, Docparser, Rossum. They are decent at email in and JSON out.

Sluice differs on the doors and on the promise.

Broader ingress. Real SFTP, FTP and SMTP servers, which means scan-to-folder and scan-to-email work straight off any office multifunctional. Konica, Xerox, Ricoh, the machine in the hallway. That is the wedge into every accountant, notary, dealership and SMB backoffice that already has a scanner and no intention of changing how people use it.

Immutable backup as a product promise. Not a retention setting. The original is written first and never touched again.

Bolt-on, not destination. A partner API with OAuth2 workspace linking, scoped tokens and return webhooks lets another product drive Sluice workspaces machine-to-machine and keep its own front end.

Sluice is not trying to become the system your team lives in. It is the layer in front of the system your team already lives in.

Where It Came From

Sluice was not invented at a whiteboard. It was extracted from Konvoi, our fleet platform, which had accidentally built a document ingestion bus while trying to process traffic fines. We pulled the bus out, replaced the hardcoded fleet taxonomy with a configurable one, fixed a bug where the OCR’d PDF overwrote the original, and made it a product. Konvoi is now a customer of it.

Hands sorting finished paperwork into a wall of labelled pigeonholes in a busy back office The last step of any document is arriving where somebody was waiting for it.

Who This Unsticks

Accountants and bookkeepers. Client documents arrive by every route ever invented. One pipeline, one review queue, per-client workspaces that never mix.

Anyone with a backoffice and a scanner. Notaries, dealerships, transport, healthcare admin. Scan to a folder like you always have. The folder is now a pipeline.

Product teams who need ingestion but not a project. Link your app to a Sluice workspace over OAuth2, push documents, receive structured data on a return webhook. Skip the six months.

Get Started

Still watching a shared mailbox? Still finding out in November that something arrived in March?

Visit sluice.glue.blue, point one channel at it, and drop a stack in the scanner.

Sluice is built by glue.blue - we stick solutions to problems. Permanently.

Ready to give your documents one way in? → Get Started → Contact Us

Posted in: Document Ingestion, AI Tools, Automation, Integration