WorkCase study
Planary
A platform my classmates and I built because school projects don't teach you to actually ship.

- 4apps live
- 3people on the team
- 6months from idea to live
Overview
Planary started as an honest answer to a frustration: school projects let you coast. You write code, demo it once, and nobody is accountable for what happens next. We wanted to know what real shipping feels like, where users notice when it breaks. So we built a platform, put it on a real domain and use it ourselves.
The problem
School builds don't hold you accountable.
You can fake progress in a school project. Miss a sprint, catch up the night before the demo, collect the grade. Nothing has to run tomorrow, so most of it doesn't. We kept finishing projects that were technically complete and practically useless.
We wanted to break that pattern. The rule: everything goes on a real domain, and real users (us) rely on it. If the sign-in service goes down, nobody gets in. A classroom never puts that kind of pressure on you, so we made our own.
Approach
One sign-in. Four real products.
Instead of one app we built a platform: a shared identity layer any app can plug into, with real tools on top. Each app had to solve a problem we actually had, so we would notice when something broke or annoyed us.
We chose Go for the backend, which none of us had used seriously before. That was on purpose: learning a language under real delivery pressure is very different from learning it in tutorials.
What I built
Four apps, one session.
Each app is deployed on its own and shares the same session. Sign in once at auth.planary.ch and it carries across every app.
- AccountSingle sign-on for every app. JWT with refresh tokens, cookies shared across subdomains and one central user store. A new app gets sign-in for free.
- DashboardThe hub after sign-in: recent activity, links to every app and quick stats. The front door of the platform.
- TournamentBrackets, seeding and results. Matches update live over WebSockets; built for and used at our class gaming sessions.
- WishlistShared wishlists that sync live between people. Built to stop us sending shop links over Discord.


Technical decisions
Why these tools.
Every big decision was deliberate, usually after trying the obvious thing first and finding it wanting.
- Go on the backendExplicit error handling and compile-time guarantees after fighting JavaScript's permissiveness. Goroutines turned out to fit WebSocket fan-out: one goroutine per connection, channels for broadcast.
- Redis pub/subLive updates go through Redis channels keyed by resource ID. Socket handlers subscribe on connect and unsubscribe on close, which keeps transport and storage apart.
- PostgreSQLBrackets are relational: rounds, matches, participants and results chained by foreign keys. We tried Redis alone first and gave up quickly.
- Docker ComposeLocal development has to match production. Since every service ran in Compose from day one, we have not had a single works-on-my-machine incident.
What I learned
The honest retrospective.
- Distributed auth has more edge cases than you expect. Concurrent refresh requests, cookies across subdomains and signing out everywhere are each simple alone. Together they multiply.
- Go changed how I think about concurrent code. Goroutines are cheap, and ownership through channels is clearer than I expected.
- Team speed is not linear. Three people communicating badly ship slower than one person. We got much better at short async decisions and stopped waiting for full agreement on small choices.
- Ship the ugly version. The embarrassing build from week two was the most useful thing we made. Using it ourselves shaped everything after it, more than any planning session did.