I recently tried to use Github Projects (Trello but make it bad*) and got so mad I started another side-project. Announcing Skyboard!

(*to be fair, these days Trello is also Trello but make it bad)

Skyboard is Trello but on the AT Protocol, a collaborative kanban board where all the data lives in your atproto repo so you control your boards forever. It is local-first, has realtime updates, works offline, is a pure client-side web app, and has a CRDT data model so collaborative edits just work.

If you know what all that means and it makes you excited go check it out now: https://skyboard.dev. If not, read on.

Kanban

A kanban board is my favorite way to track a project; you create cards that represent tasks and move them between columns that represents stages of a workflow (e.g. backlog, in progress, needs review, done). It's lightweight and fun. Looks like this:

Screenshot of a Skyboard board

Building a collaborative kanban app these days is not exactly rocket science but it still requires solving some annoying problems like data storage (servers and databases, ugh) and accounts/identity (passwords, ugh). This is all solvable and relatively cheap (or even free if the app is small enough) but still annoying to manage (or pay to have someone to manage it for you).

What if there was a better way?

The AT Protocol is the better way

The AT Protocol is the decentralized protocol used by Bluesky and a bunch of other apps. It has a lot of interesting features and properties but what matters for our purposes are:

  • identity: Bluesky accounts provide login and identity

  • repos: every user gets a folder in the cloud they can write data to and own forever

  • linked data: data in one user's repo can link to data stored in another user's repo (the links look like at://<user_id>/dev.skyboard.task/<task_id>)

  • event stream: every change a user makes is published as an event that any app can see

With just these primitives you can build a collaborative app entirely in the browser.

How it works is that each user creates their own board and tasks, which are saved in their atproto repos. To make a change on someone else's board, you write a operation that describes the action (e.g. move task T to column C on board B) you want to take place. The operation is stored in your repo and links to the tasks/boards that are stored on the other user's repo. The UI then just watches the event stream for all operations being made to a board and then displays the result.

For example, Alice makes a board called Project A with the columns todo, in progress, and done along with a task called "fix login" in the in progress column. Bob wants to move the "fix login" task into the done column and so writes an operation to his repo. The UI then combines the board/task from Alice and the proposed move operation from Bob and shows the "fix login" task in the done column.

In diagram form:

Diagram of how Alice and Bob's repos combine in the UI

Skyboard also supports fine-grained permissions. The board creator can decide if operations should be accepted by anyone, only a selected list of trusted accounts, or only the board author. Permissions don't technically prevent other users from writing operations in their own repo but the UI just ignores changes from users that aren't in the trust list.

If you are curious about how trust, permissions, and conflict resolution work check out the readme, which goes into detail.

Skyboard is still very early in development so please try it out and let me know what's working and what's not. If you have any feedback don't use Github issues, use the Skyboard issue board!