SlackVault

A free workspace forgets things. It does it quietly, which is the part that matters.

Conversations older than the retention window stop being reachable. So do the decisions inside them, and the files somebody shared, and the reasoning behind a choice nobody wrote down anywhere else. Nothing is deleted in a way anyone notices. It simply stops being findable, and the first sign is somebody asking why a thing was done and nobody being able to say.

SlackVault keeps the record without becoming its keeper.

That second half is the whole design. The obvious way to build this is a service that connects to a workspace, reads it, and stores the messages somewhere convenient, which works and makes the operator a custodian of other people's conversations. This does the opposite: the archive is written into the user's own free-tier storage, so there is no vendor server in the path that could hold anything.

Privacy enforced by architecture is a different claim from privacy promised in copy.

One of them is checkable. If there is no place in the design where a third party's server touches the data, the promise does not depend on anybody's good behaviour, including mine.

Getting there took four surfaces, and each holds exactly one thing.

The browser extension owns the workspace session, because that is where the session already lives and giving a server credentials of its own would create the custodian this avoids. A Cloudflare Worker performs the OAuth token exchange, because that requires a secret which must never reach a browser bundle. The web application reads and searches the archive. A manifest declares the scope of the whole arrangement.

Splitting a small product four ways is more work than not doing it.

The payoff is that each piece is easy to reason about and none of them can quietly acquire a responsibility it should not have. The Worker touches credentials and never messages. The extension touches messages and never holds a long-lived secret. The application reads storage that belongs to the person reading it.

Syncing is incremental.

It runs on a fifteen-minute cadence, and a full re-read of a workspace is expensive and mostly redundant, since almost nothing older has changed since the last pass. Fetching what is new keeps the operation inside a free tier, which is the constraint that decides whether a tool like this can run indefinitely or only until somebody notices the bill.

The archive is meant to be used rather than stored.

Threaded browsing and fuzzy search exist because an archive nobody can search is a backup rather than a record. It exports to JSON and imports from a native workspace export as well, so the data can leave the way it came in.

There is a rule this design inherits and it is worth stating, because it constrains the extension half more than anything else.

An extension loads no remote code. Nothing arrives after installation, which means the behaviour in the package is the behaviour for good. On a tool holding a workspace session that is not a limitation to work around. It is the reason the arrangement is trustworthy at all. The extension is built and is not on any store yet.

What it cost is setup.

The user has to bring their own storage. That is a real step and a genuine barrier, and it is the direct price of the property the whole thing exists for. A version that stored everything centrally would be easier to start using, and it would also be precisely the product this one was written in order to avoid becoming.