Learning backend development

• ExUnit docs - good review. We use CaseTemplates at work for ConnCase, ChannelCase, DataCase for DB access, EvalCase for agent evals

I re-read Elixir in Action chapters 8-12 which covered GenServers and other OTP fundamentals. I implemented a DynamicSupervisor and Registry which spawns a Game.Server GenServer per active match. The game server stores the game state, handles updates, and syncs the updated state to Postgres. The supervisor + registry smoothly handles crashes by reloading the game state from the database.

I also read Designing Elixir Systems with OTP chapters 1-4 which was a good overview of designing OTP applications, including separating out your application into layers like data, the functional core, process boundaries, etc. The game was already built out into similar layers:

• Game - Defines the game schema as a struct
• Game.Actions, Game.Commands, etc. - Define the game logic as pure functions using the command pattern
• Game.Server - Defines the game process which owns the state for an active game
• Game.System - Defines the registry and dynamic supervisor and provides a single module to add to the top-level supervision tree

I added a bot which plays the game with simple logic. This can either run in a headless mode or fully spin up processes for load testing. This will be helpful in the coming weeks to conduct more testing, and I’ll likely run this as a separate load testing service once the game server is live.

I re-read Elixir in Action chapters 1-7. It was good to revisit some of the language and OTP fundamentals. I found it interesting to notice which language features we rarely use at Knock and which standards are Knock-specific.

I also worked on stubbing out the UI for Forbidden Nublar and game logic. It was fun to quickly iterate on the design with agents although I’ll be hand coding the majority of the backend.

On the side, I’ve been playing Factorio and reading A Philosophy of Software Design. It’s fun to compare the challenges of designing software to the more spacial challenges of laying out your factory in Factorio.

I recently moved to the Platform team at Knock and want to deepen my backend skills in Elixir and related technologies. Over the next ~6 months, I’ll spend a few hours per week reading and working on a side project.

The project will be a small multiplayer game whose events feed an analytics pipeline. The project will likely include:

• Real-time core: Phoenix Channels + LiveView, one GenServer per match, Registry for lookup, ETS for hot reads, supervision tree
• Persistence: Postgres, Redis
• Analytics pipeline: Broadway consumer reads game events off SQS → ClickHouse for analytical queries
• Monitoring: OpenTelemetry or similar monitoring setup
• Deployment: deployed on AWS via Terraform or similar

Phase outline

1. Pre-work — game scaffolding

• Read: Phoenix LiveView guide, Elixir in Action (ch. 1–4 review)
• Build: Pick the game, sketch rules, ship a basic game

2. OTP & real-time

• Read: Elixir in Action (ch. 5–12), Designing Elixir Systems with OTP, Saša Jurić’s Soul of Erlang and Elixir, Phoenix Channels + Presence docs
• Build: Basic multiplayer setup

3. Storage & indexing

• Read: Indexing Beyond the Basics, DDIA (ch. 7, 11, 12), Postgres MVCC + isolation docs, Broadway / ClickHouse / Redis docs, phx.gen.auth + OWASP Auth Cheat Sheet
• Build: Players can sign up, see their match history, and check a leaderboard backed by a basic analytics pipeline

4. Distributed systems & observability

• Read: DDIA (ch. 5, 6, 8, 9), Dynamo paper (skim), OpenTelemetry Elixir docs
• Build: Improve system reliability and monitoring

5. Deployment & design write-up

• Read: AWS VPC / IAM / SQS / CloudWatch / Secrets Manager docs, Terraform Getting Started, example design docs (Stripe idempotency, Google design doc format)
• Build: The whole thing running on AWS

Week 1

• Read DDIA chapter 1
• Narrowed down on building a Jurassic Park themed Forbidden Island clone
• Worked on game design document and state machine
• Scaffoled Phoenix project