The Polkadot treasury funded $225,000 for a privacy-focused photo storage application. The application stores unencrypted personal photos on IPFS — a public network where anyone with a content identifier can retrieve the data from any gateway in the world. The company that built it shut down five weeks ago.
I am primarily active on Kusama governance. Each network has its own stakeholders and delegates, but the communities overlap significantly and the governance practices on one inevitably influence the other. I went through this case in detail because I think the pattern it reveals is worth examining.
What was promised
Referendum 1631 requested $575,000 to build PixelProof — a “decentralized Google Photos” on Polkadot. It was rejected at 99.7% Nay. A revised Referendum 1670 reduced the ask to $225,000 for a lean MVP and passed with 63% approval in December 2024.
The revised proposal explicitly promised client-side encryption. When a commenter asked how end-to-end encryption would work, the proposer responded with a detailed commitment from their CTO: “all images will be fully client-side encrypted,” with encryption keys “derived from the user’s wallet and passkey,” ensuring “only the user can access their stored images.”
What was delivered
PixelProof’s source code is public on GitHub — 23 commits, zero stars, zero forks, created October 2025 (ten months after funding). As of February 2026, pixelproof.com shows a “Coming Soon” landing page.
I read the upload pipeline end to end. The UI passes raw files to a handler, which wraps them in a FormData and POSTs to the server. The server converts each file to a buffer and sends it directly to the Apillon SDK for IPFS storage. At no point is any encryption applied. I searched the entire codebase for encrypt, cipher, AES, chacha, E2E, end-to-end — zero matches in application source code. The proposal promised client-side encryption. The code uploads raw bytes to IPFS.
This matters because IPFS is public by default. CIDs are announced to the distributed hash table publicly, and any gateway can resolve them. PixelProof includes a smart contract on Moonbeam that manages access lists — but this only controls what the web application displays to logged-in users. It cannot prevent direct access via CID. Without encryption, this access control is cosmetic. The photos are public data with a UI layer on top — arguably less private than Google Photos, which at least requires authentication at the infrastructure level.
The application’s entire storage backend depends on the Apillon SDK. Every file operation — uploads, bucket management, IPFS pinning — goes through Apillon’s infrastructure. In mid-2025, Apillon announced it was winding down, citing market conditions and Polkadot tech stack fragmentation. The platform ceased operations on January 1, 2026. The $225,000 investment is effectively stranded.
What already existed
The problem space PixelProof set out to address has mature, open-source solutions:
| PixelProof | Ente | Immich | |
|---|---|---|---|
| End-to-end encryption | Promised, not implemented | Yes — encrypts on device before upload | Optional |
| Security audits | None | 3 independent firms (Cure53, Symbolic Software, Fallible) | Open source (no formal audit) |
| Self-hostable | Depends on Apillon (shut down) | Yes (S3-compatible backend) | Yes |
| Mobile apps | None | iOS, Android, Web, Desktop | iOS, Android, Web |
| AI search | Excluded from MVP | Yes | Yes (CLIP, facial recognition) |
| Production scale | “Coming Soon” | 200M+ photos stored | 90,000+ GitHub stars |
| Cost to treasury | $225,000 | $0 | $0 |
Ente’s architecture is worth noting specifically. Its S3-compatible storage backend means it can work with any S3-compatible provider — including, potentially, Polkadot-native storage solutions like PolkaStorage or StorageHub. The path to privacy-preserving photo storage on Polkadot was never about building a new application from scratch. It was about filling the infrastructure gap that existing applications already need.
How did this pass?
Referendum 1670 had 204 voters. The contrast between the two sides is worth looking at.
On the Nay side, Permanence DAO conducted a ten-member internal review — zero ayes, four nays, two abstains — and explicitly flagged the missing competitive analysis. JAM DAO flagged the budget as excessive for an MVP. One commenter who initially voted Nay called the project “a demonstration of Apillon SDK integration rather than a solution to an ecosystem-wide need” — before flipping to Aye after a phone call with the team, citing that they seemed “genuinely committed to building something meaningful.”
On the Aye side, the public reasoning that was visible did not engage with the technical substance. No commenter checked whether the problem was already solved. The one voter who asked about encryption received a detailed commitment from the proposer — and voted Aye on a promise that was never delivered.
Here’s where I land
We spend considerable energy in this ecosystem debating the behavior of those who vote Nay. But the asymmetry is worth stating plainly: a wrongly rejected proposal can return with better arguments and a revised scope — the ecosystem loses time, not capital. A carelessly approved proposal spends real money. In this case, $225,000 on unencrypted photos on a public network, built on infrastructure that no longer exists, solving a problem that open-source communities solved years ago for free. The voters who said No were right.
That is not a comfortable observation, but it’s an important one. We should be at least as rigorous with our Ayes as we are critical of our Nays.
I opened a thread on Kusama Shield v2 asking substantive questions — about relay models, privacy guarantees, audit timelines, swap mechanism design. The team responded in detail. You could follow the exchange and come away with a clear understanding of what was being built, what the limitations were, and where the roadmap was headed. That is how it should work.
PixelProof passed without any of that scrutiny. The encryption question got a detailed answer that turned out to be hollow. Nobody asked what already existed. The dependency on a single company’s infrastructure went unexamined.
The ecosystem is in a transition period. Communication from W3F and Parity has been sparse, but significant work is underway — JAM, native storage infrastructure, runtime improvements. The technical foundation for the next phase is being built. When it arrives, the treasury will be asked to fund applications on top of it. We should be ready to evaluate those proposals better than we evaluated this one.
The questions aren’t complicated: Does a privacy claim come with a credible technical specification? What already exists in this space? Does it make financial sense against free, open-source alternatives? What happens if the underlying provider disappears?
For my part, I’m focused on Kusama. I’ve been asking for clarity on whether Kusama is meant to chart its own course or follow Polkadot’s lead — that question is still open, and the answer shapes where community effort is best spent. Until then, I’ll keep building in the open and pushing for the kind of scrutiny that makes treasury funding worth defending.