- Real zero-log architecture requires building systems that physically cannot retain or correlate user data, rather than merely promising privacy in marketing copy.
- PoofShare shifts sensitive privacy workloads (Canvas redaction, EXIF stripping, and UPNG compression) into the client browser before network transit.
- A strict dual-domain perimeter (
poofshare.comvspoofshare.pages.dev) isolates primary application pages from untrusted user media streams. - Content-addressable storage (CAS) deduplication with physical filename isolation prevents edge cache collisions when re-uploading modified images.
- An automated cron shredder operating every 15 minutes enforces physical deletion of expired blobs across our distributed headless storage mesh.
The Problem with "Zero-Log" Marketing
Almost every modern privacy service claims to be "zero-log." Virtual private networks, secure email providers, and ephemeral image hosts regularly place bold banners on their homepages promising that your activity is never recorded.
Yet in reality, the vast majority of these platforms run traditional server architectures: NGINX access logs recording client IP addresses, load balancer telemetry streams tracing connection timestamps, and relational database backups retaining metadata indefinitely. When pressured by legal subpoenas, infrastructure bugs, or security breaches, these "zero-log" claims frequently unravel.
When we set out to build PoofShare, we took a fundamentally different engineering philosophy:
True privacy cannot depend on trust. If a system stores your IP address or raw unredacted files on a disk, your privacy is conditional. A genuine zero-log architecture must be engineered so that the backend server is technically incapable of logging, correlating, or recovering user identities.
In this architectural overview, we explore how PoofShare was constructed on Cloudflare serverless edge infrastructure, the non-trivial distributed systems challenges we solved, and the engineering trade-offs required to enforce ephemeral data lifecycles.
1. Client-Side First: Eradicating Secrets Before Transit
The most secure network packet is the packet that is never sent. Traditional web platforms ingest raw files from users and perform processing (resizing, watermarking, virus scanning) on centralized backend servers. This pattern means the server always possesses the unredacted master asset, complete with private camera metadata and sensitive data fields.
PoofShare inverts this paradigm. We treat the user's web browser as an active cryptographic and processing node:
In-Browser HTML5 Canvas Redaction
When you obscure a credit card number or server password, our Quick Blur and Pixelate Redactor tools execute directly on an offscreen HTML5Canvas element. The pixel buffer (ImageData) is mathematically overwritten in browser RAM before upload. The unredacted pixels never touch the network cable. As we explored in our analysis of why drawing over screenshots with a phone marker fails, destructive pixel destruction in memory is the only mathematical guarantee against exposure reversal.
Client-Side EXIF Scrubbing
Smartphone camera photos contain embedded GPS coordinates and hardware serial numbers. Our client engine decodes image streams into raw raster bitmaps, stripping all APP1 markers, EXIF structures, and XMP blocks before initiating the upload request. To understand how dangerous raw camera tags can be, review our investigation into hidden EXIF metadata risks in photos.In-Browser UPNG Quantization
To keep payloads light without smudging typography, PoofShare runs self-hosted UPNG quantization algorithms inside your browser. This reduces PNG payload sizes by up to 70% prior to dispatch. For a detailed comparison of image codecs, see our guide on WebP vs PNG vs JPEG for screenshots.2. The Dual-Domain Perimeter: Sandboxing Untrusted Media
One of our most critical architectural requirements was maintaining zero-leak user privacy without exposing viewers to third-party tracking scripts or persistent cookies.
Untrusted User-Generated Content (UGC) must always be quarantined from primary web applications. When user-uploaded media shares a domain with core applications, tracking scripts, third-party tags, or malicious embeds can access session state and inspect DOM contents, creating severe privacy risks for users viewing sensitive temporary screenshots.
We solved this through an edge-enforced Dual-Domain Perimeter:
Zone 1: poofshare.com (Clean Editorial & Ingestion Gateway)
- Hosts static landing pages, feature tutorials, legal terms, and our technical Blog.
- Houses editorial guides, technical documentation, and product resources under strict content hygiene.
- Hosts the upload gateway where client-side redaction and compression occur.
- Any incoming request to view media (
/v/:slug,/i/:slug,/t/:slug,/g/:slug) is issued an HTTP 301 redirect topoofshare.pages.dev.
Zone 2: poofshare.pages.dev (Untrusted Ephemeral Media Sandbox)
- Houses the ephemeral viewer (
/v/:slug), raw image stream delivery (/i/:slug), and multi-image galleries (/g/:slug). - Completely quarantined: zero third-party tracking pixels, zero marketing scripts, and zero persistent analytics tags.
- Any navigation to marketing routes (
/,/about,/privacy) is issued an HTTP 301 redirect back topoofshare.com.
Both edge domains bind to a shared Cloudflare D1 serverless database instance. This architecture achieves total separation: core application routes never serve unvetted UGC media, and users viewing ephemeral links are never tracked by external scripts.
3. Storage Mesh & Content-Addressable Deduplication
When handling millions of ephemeral uploads, physical storage must be fast, geographically distributed, and cost-efficient. PoofShare routes uploads to a headless multi-worker storage mesh.
The Storage Filename Collision Challenge
To optimize storage costs, our system uses Content-Addressable Storage (CAS): we compute the SHA-256 hash of every sanitized image stream. If two users upload an identical image, the physical blob is stored only once in the master storage tier.However, during real-world testing, this created a subtle edge caching bug. When a user uploaded an image, noticed a mistake, cropped it in our editor, and re-uploaded it under the identical user filename (screenshot.png), Cloudflare's Tier-1 edge cache occasionally served the cached version of the previous upload because the origin request URI matched.
We resolved this by strictly decoupling logical user filenames from physical origin filenames:
// Decoupled Physical Storage Key Generation
const uniquePrefix = `${Date.now()}_${fileHash.substring(0, 8)}`;
const physicalFilename = `${uniquePrefix}_${sanitizedBase}${ext}`;The database maps public short slugs (/i/:slug) to physical storage keys, completely isolating edge cache entries while preserving the original user-facing download filename in Content-Disposition headers.
4. The 15-Minute Automated Shredder Lifecycle
An ephemeral host is only as good as its deletion mechanism. Many legacy hosts merely mark expired records as hidden in a database, allowing physical files to linger in storage buckets indefinitely.
PoofShare enforces a two-tier deletion lifecycle:
- Logical Instant Invalidation: Every upload and multi-image gallery record in Cloudflare D1 includes a strict
expires_atUnix timestamp. The momentDate.now() / 1000 >= expires_at, edge gateway workers immediately return a branded HTTP 404 response. No public request can access an expired asset. - Physical Cron Purging: A dedicated companion background cron worker runs on an automated 15-minute schedule. Every 15 minutes, the cron queries D1 for expired aliases, resolves their upstream storage nodes, issues physical deletion commands to the origin storage mesh, and blacklists the purged records.
-- Automated Shredder Cron Query
SELECT alias_id, storage_node, physical_key, file_hash
FROM active_records
WHERE expires_at <= ? AND status = 'active'
LIMIT 100;This guarantees that expired files are not simply hidden; they are physically expunged from disk arrays across the globe.
5. Solving the Burn-on-Read Race Condition
One of the trickiest distributed systems problems we encountered involved our Burn on Read feature for multi-image galleries (/g/:slug). Learn how multi-image drop workflows operate in our guide on sharing bug reports and screenshots cleanly.
Burn-on-read dictates that as soon as a recipient views the gallery, the files must self-destruct. However, modern browsers prefetch images in parallel: when a gallery page opens, the browser may fire four concurrent requests for individual thumbnails and master images simultaneously.
In an uncoordinated serverless environment, the first thumbnail request would trigger the self-destruct counter, immediately deleting the database record and causing the remaining three thumbnails to fail with HTTP 404 errors!
We solved this through an explicit confirmation gate with in-memory session hydration:
- When a burn-on-read gallery is requested, the server delivers an interactive warning gate without fetching any raw media streams or thumbnails.
- Once the recipient explicitly clicks View Gallery, the viewer triggers an atomic deletion request to the database, marking the gallery destroyed on the server.
- Concurrently, the client streams the gallery assets directly into browser memory as local Blob URLs. The images render smoothly in the active DOM and lightbox while remaining completely purged from the edge network.
Architectural Trade-Offs: The Cost of Absolute Privacy
Building a zero-log ephemeral service involves deliberate technical trade-offs:
| Engineering Dimension | Traditional Host | PoofShare Zero-Log |
|---|---|---|
| Server CPU Usage | High (remote image resizing) | Near Zero (offloaded to client browser) |
| Edge Cache Hit Ratio | High (assets cached for months) | Intentionally Lower (strict TTL invalidation) |
| User Troubleshooting | Easy (inspect server IP logs) | Hard (zero IP or access logs retained) |
| Data Liability | High (accumulates massive user data) | Zero (files physically shredded on schedule) |
By trading away centralized logging and perpetual caching, we gain something far more valuable: a platform where users can share confidential bug reports, legal screenshots, and private visual notes without creating a permanent trail across the internet.
Review our complete legal commitments in our Privacy Policy and learn about the engineering team behind PoofShare on our About Page.
How can I verify that PoofShare does not log my IP address?
You can inspect your browser network inspector when uploading or viewing images. You will observe that zero analytics trackers, third-party cookies, or fingerprinting scripts are loaded on media routes. Furthermore, our edge workers operate statelessly on Cloudflare V8 isolates without persistent log disks.
What happens if a server crashes during an upload?
Because all redaction and compression occur client-side in browser memory, no incomplete or unredacted fragments remain on our servers. An interrupted upload simply terminates the HTTPS connection cleanly.
Does Cloudflare D1 retain deleted records?
No. When the cron shredder executes, it deletes or updates the status to purged. Serverless SQLite WAL checkpoints continuously consolidate state, ensuring physical disk pages are reclaimed.
Why is physical deletion handled by a cron instead of the request worker?
Purging physical files from distributed storage origins involves outbound network calls to storage mesh nodes. Offloading deletion to an asynchronous cron worker keeps edge response times under 15ms for public users.