You open the background remover, drop in an ID photo, and 3 seconds later you have a transparent PNG. Where did your photo go in that process?

Answer: nowhere.

Sounds like marketing speak. But this time it’s real. This post explains:

  • Why Piick insists on 100% client-side processing
  • How it’s done (technically, no fluff)
  • The 4 core principles and 3 technical safeguards
  • When “local processing” is actually a disadvantage

Why This Matters

Here’s a concrete scenario.

You run cross-border e-commerce and your company is launching on Amazon US. You need 1,000 product shots: white background, 800×800, JPG, under 500KB. You pick an online tool, register, upload, download — your image visits:

  • The tool’s CDN (maybe Singapore, maybe Virginia)
  • The tool’s GPU servers (processing)
  • The tool’s object storage (result caching)
  • The tool’s backup system (offsite DR)

Your product shots (including unpublished, next-season designs) have been copied at least 3-5 times into locations you can’t control. The image might be your company’s core selling point for the next 6 months.

Or a more personal scenario: you took a first-birthday photo of your kid and want to fix the background. The kid’s face, your home address (in the background), your family’s daily life — this is as sensitive as a credit card statement.

This isn’t a question of “can you trust the tool?” It’s that any link in the data-transit chain could leak.

Piick’s solution: eliminate the transit step entirely. The algorithm runs in your browser; the image never leaves your device.

Piick’s 4 Core Principles

Principle 1: Zero Upload

All image processing tools — image compressor, image format converter, image cropper, background remover, batch OCR, color extractor — process images in the browser using JavaScript + the Canvas API.

Network requests only happen when the page loads (HTML / CSS / JS static assets). Once the page is loaded, drop your image in, and the entire processing pipeline makes zero further network requests.

How to verify? Open your browser’s DevTools → Network panel, set all request types to “All”, and run a complete workflow. The requests you should see:

  • The page’s HTML
  • Static CSS / JS files
  • Fonts (if any)
  • Zero POST / PUT requests to any API endpoint

Principle 2: Zero Account

No “login to download results” gates. No “free for 5 images, then pay” limits. Open, use, leave, close — your browser is the only place any trace exists.

Technically: Piick stores no user data (because there is no user data to store). No user_id, no device fingerprint, no tracking cookies.

Principle 3: Zero Cost ≠ Low Quality (Monetization without Surveillance)

Piick monetizes through page ads (Google AdSense). User data is not sold to advertisers — because there is no data to sell.

This is fundamentally different from mainstream SaaS tools (remove.bg, Adobe Express, Canva). Their free tier + Pro tier model treats free users’ images as data: analyzed, used to train models, sold to advertisers. Subscription fees cover Pro costs, but the free tier pays for itself with data.

Piick’s choice: only ads as a monetization channel, and advertisers don’t get access to your content data.

Principle 4: Open Audit Trail

All tool processing code is bundled into JavaScript files that anyone can inspect with DevTools. Algorithm logic is public, auditable, and untamperable (because the code runs in the browser, not on a server).

Unlike some tools that “claim local processing but secretly upload,” Piick’s code will be open-sourced on GitHub (planned), so any developer can audit the implementation.

3 Technical Safeguards

Safeguard 1: Canvas API + OffscreenCanvas

All Piick image processing uses the browser’s Canvas API (and OffscreenCanvas for Web Worker scenarios). Canvas API is implemented in the browser engine, runs entirely client-side.

For the background remover specifically:

  1. You drop in an image → browser uses createImageBitmap() to decode it to RGBA pixels
  2. JavaScript runs the BFS flood-fill algorithm on those pixels to generate an alpha mask
  3. Canvas draws the processed pixels
  4. canvas.toBlob() encodes the result as PNG/JPG binary
  5. Browser triggers a download of the Blob

None of these steps make HTTP requests to Piick’s server or any third-party server.

Safeguard 2: Web Workers (For Batch Scenarios)

For CPU-heavy tasks like batch OCR, Piick uses Web Workers to run algorithms on background threads. Benefits:

  • Doesn’t block the UI (progress bar updates smoothly)
  • Doesn’t spike memory (workers have isolated memory)
  • Still pure client-side — workers are just multi-threading inside the browser, not network

OCR uses Tesseract.js. The library’s model files (English + Simplified Chinese language models) need to be downloaded on first use. This is different from “uploading your image”:

  • Model files come from Piick’s CDN (public assets, no user data attached)
  • Your image OCR result stays in the browser; it never leaves

Safeguard 3: Zero Server-Side Persistence (Server-Side Stateless)

Piick’s “server” (if you can call it that) does one thing: return static files.

Technically piick.cc is a pure-static Astro site deployed on a CDN (Cloudflare or Vercel). The CDN runs no application code — no database, no filesystem, no user table. Piick’s server is technically incapable of storing your image, even if it wanted to.

This is a stronger guarantee than “trust us not to save.” “We can’t save” is the better guarantee.

When “Local Processing” Is Actually a Disadvantage

Honesty time: 100% local isn’t always the optimal choice.

Scenario 1: Complex AI Model Tasks (Hair Extraction, Semantic Segmentation)

Piick’s corner-sample + flood-fill is great for solid-color backgrounds (80% of user cases), but hair strands, semi-transparency, complex gradients are out of reach. Those need cloud AI models (like remove.bg’s U²-Net), which are a few MB to tens of MB.

Trade-offs of cloud solutions:

  • ✅ High accuracy on complex scenes (hair-level)
  • ❌ Image must be uploaded to the server
  • ❌ Usually paid (a few cents to a few dimes per image)

Piick V1 chose the local algorithm (simple cases + zero cost + privacy). V2 will consider adding a “high-quality mode” toggle that downloads an AI model in the background; both the model and your images stay in the browser (similar to @imgly/background-removal), but the model download itself is a one-time large file.

Scenario 2: Very Large Batches (Thousands of Images in Parallel)

Local processing is limited by your device:

  • CPU: browser BFS is 200ms/image on phone, 50ms/image on desktop
  • Memory: each 4K image decodes to ~33MB; 1,000 loaded at once blows memory
  • Disk: your SSD has to handle the bulk ZIP download too

Cloud solutions use GPU servers for parallelism, finishing thousands of images in seconds.

Piick’s batch background removal currently processes sequentially (one at a time), suitable for 5-50 image small batches. For 1,000+ image scenarios, you need commercial tooling.

Scenario 3: Collaboration / Cross-Device

If your workflow is “process some on Mac at home, continue on Windows at work,” local processing has no cloud sync; you manually transfer files.

Cloud solutions natively support collaboration (shared folders, version history, cross-device sync).

Scenario 4: Compliance Requirements

Some industries (healthcare, finance, government) have mandatory “data processing log” requirements, requiring the server to record every processing event (object, time, operator). Local processing has no such log.

Piick doesn’t target these scenarios. If you’re doing medical imaging, skip Piick and go straight to professional DICOM tools.

How to Verify Piick Really Doesn’t Upload

The most direct verification method — DevTools Network panel. Step by step:

  1. Open piick.cc/tools/background-remover
  2. Press F12 to open DevTools
  3. Switch to the Network panel
  4. Clear the log (🚫 icon)
  5. Check Preserve log (so the log survives page reloads)
  6. Filter by piick.cc or leave empty
  7. Drop an image in, complete a full background removal run
  8. Observe the request list: aside from page-load HTML/CSS/JS, there are no POST/PUT requests during processing

If you find any suspicious request (domain is not piick.cc, method is POST/PUT, payload is non-empty), screenshot and send it to us — that’s a bug.

Deeper verification:

  1. Offline test: load the page, turn off network (airplane mode or unplug the cable), run the tool again — should work completely, since all JS is already loaded in browser memory
  2. Offline cache: cache the entire piick.cc site locally (Chrome’s “Make available offline”), then go fully offline, run the tool
  3. Third-party audit: Piick’s open-source code will land on GitHub (planned Q3 2026); developers can audit Canvas API calls and confirm there are no fetch() calls uploading images

FAQ

Does Piick really not store my image?

Really. Technically Piick’s server is incapable of storing — it’s a pure static site with no database and no application server. The image is processed on the browser Canvas; the result downloads directly to your device; it never touches Piick’s server.

Then how does Piick make money?

The Google AdSense ads on the page. Visitors see ads, advertisers pay. That’s it.

Will Google see my image?

No. AdSense loads ad scripts that read your page URL and device type to serve relevant ads, but do not read image content you drop into the tools (ad scripts run in iframe sandboxes with no interface to the Canvas API).

After I process an image, does Piick’s CDN cache it?

No. The CDN caches only static files (HTML/CSS/JS), not any user content. Your image doesn’t even reach Piick’s CDN — it goes straight from browser to your hard drive.

Will Piick ever do server-side AI processing?

No. This is a Piick core principle — no server-side image processing. Any “AI-enhanced features” (hair extraction, super-resolution, style transfer) added to Piick must be implemented with local models in the browser; we won’t secretly upload to the cloud.

I want “ultra high-quality” hair extraction. Any cloud solutions Piick recommends?

Honestly — Piick doesn’t make commercial recommendations; that’s not our scope. But community-popular cloud solutions for hair extraction include: remove.bg (cheap, good hair), Adobe Express (subscription, best overall experience), Photoroom (e-commerce-specific, with product-shot background-replacement templates).

Before using a cloud solution, make sure you trust the tool’s terms of service, understand the data flow, and sanitize sensitive content (product shots are OK, but ID photos of kids are best not uploaded).

One-Line Summary

Piick doesn’t transmit your image not because of a marketing promise, but because technically it cannot — the site is pure static, with no server-side storage capability. The algorithm runs in browser Canvas; from drop-in to download, the image never leaves your device.

Open piick.cc/tools/background-remover, press F12 to open Network panel, and verify it yourself — that’s the most reassuring.