You send a proposal and, most of the time, hear nothing back. DeckTrail gives each client their own private, branded space for the work you sent, and shows you what they did with it: who opened it, which parts held them, how far they read. Built for the way work moves in the AI era, and hosted entirely on your own server.
Three things that are real, in that order: confidential delivery, engagement you can see, and work that stays yours. There is no fourth thing called prevention, and the honest limits are further down this page.
Every recipient gets their own link behind a passwordless sign-in. No public URL, and no anonymous forwarding: the link is theirs alone. Every open ties to a named person, which is what makes everything after it possible.
Who opened it, which parts they stayed on, how far they read, and whether they finished. Per person and per deck, on your own dashboard, and exportable whenever you want it.
It also shows what got tried against the copy protection: copy, print, and download attempts, and tripwires broken down by reason. The selection tripwire only fires once a selection exists at all, so it catches someone who defeated the stylesheet that keeps an ordinary reader from selecting text in the first place, not the ordinary reader.
Draft the deck with AI on your own machine: your own Claude login needs no API key, or point it at a free or local model instead. It goes out watermarked to the reader at serve time, and known AI agents are turned away at the door. Everything runs on your server, so nothing ever touches ours.
Three ways to do the writing, and you are not locked to one: your Claude login, a free or local model, or your own routing gateway.
The whole thing runs from your own machine and your own server. Here is the entire path, from a file of rough notes to a client reading it, with nothing left out.
# once, to install and finish setup ./scripts/up.sh # open the link it prints, name yourself, set your brand # once, so the tool knows your portal export DT_PORTAL_URL=http://localhost:3000 export DT_PORTAL_TOKEN=<from your .env> # then, per deck decktrail generate notes.md --client acme --out deck.json decktrail render deck.json --layout crest --out preview.html decktrail push deck.json --recipient priya@acme.example
render writes one
self-contained HTML file. Open it, change the layout or the theme, render again. Your
content does not move.push publishes it and mints a link
for that address alone. They sign in without a password and read it in the browser./admin fills in: who opened it,
when, how often, which decks, and every scraper turned away at the door. The whole event
log downloads as a CSV.Generation runs on your machine, not on the server, so your content never leaves it on the way to becoming a deck. The only thing that reaches the portal is the deck you chose to publish.
The common thread is work that carries your thinking, going to someone you want to keep dealing with.
The case you spent three days building, sent to one person instead of into a thread that gets forwarded. You find out whether they reached the pricing slide, and whether they went back to it.
The proposal, the commercials and the scope of work behind one gated landing, so the client has a single link that keeps working instead of four attachments they have to dig for.
Every copy carries the reader's own name at the moment they open it. It does not stop a photograph, and it does mean any copy in the wild says whose it was.
A real engagement is rarely one deck. Group the proposal, the commercials, and the scope of work behind a single gated landing, and send the client one link.
They sign in once and land on their own index. Each card opens a gated, watermarked, tracked artifact: a deck, a document, or a live pricing tool. The landing is gated to that person exactly like the artifacts, so a forwarded link opens for nobody else.
You are handing this to a client you respect. You deserve to know exactly where the floor is, from us, before you meet it in the wild.
| What can still happen | Can DeckTrail stop it? | What you actually get |
|---|---|---|
| Photograph the screen | No. Never. | Their name is in the photo. |
| Paste the text into a model | No. | You know who had it open, and for how long. |
| Retype it by hand | No. | Dwell time on the slides they retyped. |
| Right-click, select, copy | Friction, not a wall. | The attempt is logged against their name. |
| Forward the link to a colleague | Yes, meaningfully. | The link is theirs. The colleague has to ask you. |
| Point a scraper or AI agent at it | Known ones, yes. | 403 at the door, and it shows up in your log. |
We will not tell you the first three can be stopped, because they cannot be, by anyone. What changed in the AI era is not that leaks became possible. It is that a leak now regenerates into something that reads as original. Attribution is the thing that still survives that, so attribution is what we build.
decktrail revoke <shareId> ends a share. The link stops resolving, and if
the recipient signed in earlier and is reading it right now, that session ends too, not only
their next visit. Revoke it twice, or revoke one that never existed, and you get the same
answer both times.
It reaches the link, not a copy already taken. Whatever they saved, printed, or photographed before you revoked it is still theirs, the same as everything above.
There is no account to make here, because there is nothing here to sign into. You clone it, you run it, and your clients' decks live on your server where they belong. We could not read them if we wanted to.
Postgres and a container, a browser form to set your brand and mail, and you are serving. The setup wizard generates its own secrets on first boot, and its mail step can send a test message using the SMTP values you just typed, not anything saved yet. If sending fails, it shows you the mail server's own error instead of quietly logging it and moving on.
On a real server, put it behind the bundled Caddy or your existing Traefik for automatic HTTPS. The server guide walks through both, and you generate decks on your own machine, never on the server.
You need Docker and Node 24 or newer on that machine first. The script checks for both and stops with instructions if either is missing.
# macOS, Linux or WSL git clone https://github.com/orbitqube-tech/decktrail cd decktrail ./scripts/up.sh # Windows, in PowerShell .\scripts\up.ps1 # or from cmd.exe, same thing scripts\up.bat # it generates its own password, waits until the # portal answers, builds the command line tool, # and prints the link that finishes setup
Every deck DeckTrail renders carries a small "Made with DeckTrail by OrbitQube" in the corner. The licence does not require it, and you can turn it off without asking us.
We are asking instead. This is free software with no trial funnel and no hosted tier steering anyone back to us, so a consultant noticing that mark on a deck is genuinely the only way the next person finds this. If it saves you a subscription, leaving it on is a fair way to pay that forward. If not, that is fine, and you owe us no explanation.
We drafted a licence term to make it mandatory, then read the AGPL properly and found the term would not have held. So we dropped it rather than ship something that reads enforceable and is not. The reasoning is written up in the repo, including the parts that went against us.
The name is the one thing we do protect. Run it, fork it, sell services with it, no permission needed. Just give your fork its own name.