
PrivacyPrint: Print Confidential Files Without Leaving a Trace
A print-shop workflow where customers configure and auto-delete their own documents, so sensitive files like Aadhaar and PAN cards never sit on a shop's computer after printing. Built with Lambda, DynamoDB, S3, and an event-driven expiry worker.
PrivacyPrint: Print Confidential Files
Without Leaving a Trace
Built at First Commit, WeMakeDevs x AWS, Bharat Builds Tour, September 2026
The moment this idea was born
It didn't start with a whiteboard. It started at a photocopy shop.
One of our teammates, Utkarsh, was there getting college PDFs printed when a woman walked in with an important personal document. The shopkeeper stepped inside to print it and got held up. Minutes passed. The longer he took, the more anxious she got, until she snapped: "What are you doing with my document? Are you going to make extra copies and misuse it later?"
The shopkeeper, understandably, got defensive too. He wasn't doing anything wrong, he was just doing his job. But her fear wasn't irrational either: once you hand over an Aadhaar card, a PAN card, or a signed application at a print shop, the file usually just sits on that computer. Nobody deletes it. Not out of malice, just because nobody's job is to remember to.
That single, tense exchange was the whole problem statement. Two people who trusted each other by default, with no system to make that trust unnecessary.
The idea
PrivacyPrint puts the customer in control of the entire print job, and takes the decision making off the shopkeeper's plate entirely:
- Customer uploads the document and configures everything: copies, page range, color/B&W, paper size, duplex, orientation
- Customer also sets a privacy retention window: 10 minutes, 30 minutes, 1 hour, up to 3 days
- The shopkeeper sees a clean, pre configured job card and just clicks Print
- Once the printer confirms the job is done, the countdown starts
- When it hits zero, the file is permanently purged. No manual step, no "forgot to delete it"
No logins for the customer. No permanent cloud storage of sensitive documents. The shop never sees another shop's queue, and the customer's file exists only long enough to become paper.
Team
We're a three person team, Will Of Fire:
- Utkarsh Yadav (1st year) the idea originated with him, from the incident above, and he sourced the actual physical printer that let us move this from a simulated demo to a real hardware integration
- Nitin Kumar Yadav (3rd year, team lead) AWS backend implementation: Lambda, DynamoDB, the expiry worker, and the print connector/printer detection layer
- Yash (4th year) architecture and frontend: designed the multi tenant system architecture, and built the customer flow, shop dashboard, and the UI redesign that took it from a generic CRUD looking app to something that actually looked like a product
Each piece depended on the other two, there's no version of this project that ships without any one of them.
Architecture
We went with a multi tenant design from the start, architected by Yash, since the whole point is that Shop A can never see Shop B's queue, and neither can see a document meant for the other.
- Lambda (Function URL) for the API layer and web hosting, fronted by CloudFront for HTTPS and stable delivery
- DynamoDB as the job store: status, specs, expiry timestamps
- S3 for short lived document storage, with the expiry worker deleting the object before the DynamoDB record transitions state (not the other way around, we didn't want a window where the metadata says "deleted" but the file is still sitting in a bucket)
- Event driven expiry worker (Lambda) fires on the retention schedule set at upload time and tears the document down automatically
- Print connector, a local agent that talks to the actual printer: CUPS on Linux/Mac, with a SumatraPDF silent CLI fallback for Windows, plus zero touch printer detection so the shop doesn't have to configure drivers
System architecture

Print job lifecycle

What fought back
The idea was the easy part. Building it was a fight, in this order:
1. The simulation looked like nothing. Our first working version confirmed print jobs through a simulator, no real printer involved. Functionally it worked, but demo wise, it just looked like any CRUD app. No emotional weight, no "wow." We knew judges wouldn't feel the problem unless they saw a real piece of paper come out of a real machine.
2. We didn't have a printer. Simple problem, annoying solution: we had to arrange one. Utkarsh sourced it, without that, the pivot to real hardware doesn't happen at all.
3. The app couldn't find the printer. Even with hardware in hand, our connector couldn't locate the printer's directory, so print requests silently failed to go anywhere. Debugging this, and building proper printer detection so the shop wouldn't need to configure anything manually, ate a real chunk of our time.
4. Windows wouldn't cooperate with CUPS. Our first print connector was CUPS based. It worked, but not everywhere. We ended up adding a separate silent printing path via SumatraPDF's CLI to get reliable printing on Windows machines too.
5. CORS, repeatedly. Once we moved to a real AWS deployment (Lambda Function URLs and CloudFront), we hit a string of CORS failures: wildcard methods breaking Function URL validation,
AllowOrigins rejecting our config, blocks that needed isolating just to find which layer was failing. It took several iterations to land on a config that actually held.6. A crash from a dependency mismatch.
uuid v14 turned out to be ESM only, which crashed our Lambda outright. Pinning to v9 (CommonJS) fixed it, a reminder that small dependency upgrades can break serverless functions in ways that are invisible until deploy time.7. Security basics, done properly. We added protection against spoofed documents and tightened self sign in, so a job can't be faked or hijacked mid flow, important given what these documents actually are.
None of these were glamorous problems. But each one was the difference between a demo that describes privacy and one that proves it.
Where it stands now
End to end, the flow works: a customer uploads a real document, sets specs and a retention window, the shop sees a clean job card, clicks print, a physical printer produces the page, and the file disappears on schedule afterward, with no one having to remember to delete anything.
The bigger idea we keep coming back to is simple: files should have a lifetime. For this hackathon, we scoped that down to one very specific, very real moment: a person standing at a print shop counter, waiting, worried about a document they can't afford to have floating around. Solving that moment well felt like enough for four days.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article