ELO Darts – Scalable Real-Time Darts Platform

Building ELO Darts started with a simple idea: make online darts feel as responsive as playing at the board. The hard part wasn’t the UI – it was delivering consistent, real-time performance at scale for matches, tournaments and stats across many concurrent players.

This project is my full-stack take on that challenge – and the main story is how we solved performance and scaling for live data.

The Problem & Vision

Real-time apps are easy when you have a few users. They get hard the moment you add:

• Parallel matches and tournaments
• Live scoring, video, and chat
• Constant updates to stats and rankings

The vision: a platform where every score, camera frame and state change feels instant, even when many matches and events run in parallel.

---

Key Product Features

• Real-time webcam matches with synchronized scoring
• Match lobbies and tournaments with automated brackets
• Player statistics and rankings updated from live data
• Club & association spaces with events and results
• All games are live-streamed on the platform

The product side is important – but the technically interesting part is what’s under the hood.

---

Architecture & Real-Time Scaling

The stack is built around modern web tooling and a real-time core:

• Frontend: Next.js, React, Tailwind, shadcn/ui
• Backend: Node.js, Express, Prisma
• Real-time: Socket.IO with Redis for horizontal scaling
• Database: PostgreSQL, Redis
• Background Jobs: Trigger.dev
• Infrastructure: Infrastructure: Dockerized services on Hetzner servers with load balancing

The biggest challenge was keeping real-time traffic fast and predictable as usage grew.

Solved it by:

• Using Socket.IO + Redis so multiple Node instances can handle WebSocket traffic while staying in sync.
• Designing room-based channels (per match, per tournament, per club) to avoid broadcasting unnecessary data.
• Offloading heavy work (statistics recomputation, rating updates, integrity checks) to background workers via queues, so the request/response path stays lean.
• Optimizing PostgreSQL queries and indexes around the read patterns of live dashboards and match views.
• Adding metrics and tracing to spot hot paths and tighten bottlenecks before they become visible to users.

The result is a setup where we can spin up more backend instances and Redis continues to fan out events reliably, keeping latency low even under load.

---

What I Learned

This project was a deep dive into real-time systems at scale:

• How to design WebSocket APIs and room structures that stay manageable as features grow.
• How to separate “must be real-time” work from “can be async” tasks to keep the UX snappy.
• How monitoring, tracing and good database design are just as important as clever code when you deal with live data.

ELO Darts is more than just a darts app in my portfolio – it's my reference project for scalable, real-time architecture. The stack spans a Next.js frontend, a Node.js/Express backend with Prisma, horizontally scaled WebSockets via Socket.IO + Redis, and background job processing with Trigger.dev – all tied together with a data model and infrastructure built to handle serious load.