All projects

Competitive stats hub for the CJ League

Raw API data turned into real rivalry, on a platform built for the community and run by it.

Role
Product Designer + Dev
Timeline
2026
Platform
Web + Mobile
Team
Solo project
Competitive stats hub for the CJ League

Overview

CJ League is a private CS2 league with about 40 regular players, organized in a private FACEIT hub. The group was already engaged and competitive, but had no view of individual or group performance beyond what FACEIT shows out of the box.

Data visualizationNext.jsUX Design

The challenge

What FACEIT doesn't offer private hubs:

  • A consolidated leaderboard per league season
  • Performance comparison between players in the group
  • Map distribution across the season
  • Rank changes over time
  • A visual identity for the league (everything was generic FACEIT)

To find out who was playing best in a season, players had to leave the platform, cross-check data by hand or rely on the group's memory in Discord.

Design problem statement:

How might we turn raw API data into a stats hub that fuels competition and a sense of belonging, brings people back after every match, and can be run by the community itself?
Faceit platform limitations

Research & users

Who uses it and what they expect

The group is small and easy to reach, so research was direct: I watched how people behaved in Discord and talked to them during matches. Three profiles came up:

  • The competitive player: follows every match closely. Wants to know exactly where they rank and what it takes to climb.
  • The casual player: plays for fun but likes checking the group's stats afterward. Engages if the data is easy to read.
  • The organizer: needs data for concrete decisions, like seeding pots, prizes and balancing the next season.

What I learned:

  • Players opened FACEIT after every match and left frustrated by the missing league context
  • People built informal rankings by hand in Discord, which showed real demand for structured data
  • The CJ League identity created a sense of belonging that FACEIT didn't reflect
  • Seeding pots were tracked from memory, and that data needed to be visible and easy to look up

Player card anatomy

The core unit of the leaderboard

The player card is the most repeated element on the platform. It shows up on the season leaderboard and sums up what matters about each player in a scannable format. I designed it to work as a compact list row and as an expanded, more detailed view.

Card elements:

  • Leaderboard position, with the top 3 highlighted
  • Player avatar, pulled from their FACEIT profile
  • Pot indicator (1 to 5), the skill tier within the league
  • K/D ratio as the main performance metric
  • Total matches played in the season
  • Win rate
  • An internally calculated rating (a composite league metric)
The compact card prioritizes quick scanning — the player opening the site wants to see their rank and K/D in under 2 seconds.

Player page anatomy

Every player has their own page, opened from the link on their card. It brings together the player's full season history and gives a deeper read than the leaderboard.

Page sections:

  • Header: large avatar, nickname, current pot, leaderboard position and a summary of key season metrics. It's the profile's visual identity.
  • Season stats: K/D ratio, total matches, win rate, kills, deaths, assists and headshot percentage, all for the active season.
  • Rank over time: a timeline of how the player moved up and down during the season, showing whether they're improving or slipping.
  • Comparison: where the player stands against the league average and players in the same pot, context the leaderboard alone can't give.
  • Match history: every match of the season with map, result, K/D, kills, deaths and assists, newest first.
Design decision: the player page is for people who want more than the leaderboard snapshot. The rank chart shows consistency: where a player stands and how they got there.
Player page anatomy

Admin panel

One premise of the project was that the site had to work without me. I designed the admin panel so a league organizer with no technical background could keep the platform up to date, manage seasons and understand what's going on behind the scenes.

Data updates

One main button fetches new data from FACEIT and updates the database. The panel shows when the last update ran, how many matches are indexed and whether it worked. Nobody has to touch code or the server to keep the site current.

Cache control

A screen to clear the Redis cache per season or force a full refresh. It shows when the cache was built and how much data it holds, so the operator can tell fresh data from stale.

Season management

Create and activate a new season without touching code. Each season has its own namespace, so past seasons stay intact and the new one starts clean.

Player management

Add, remove and edit players, including FACEIT nickname, pot and profile details. The organizer keeps the roster current between seasons without a deploy.

Site guide

A guide written inside the panel itself, explaining what each section does, when to use each action and how to read the status indicators. It's written for the person running the site, in plain language, not as a technical README.

Design decision: I treated the admin panel as a product, not an internal tool. Every action gives clear feedback, every state has visual context, and the built-in guide lets any organizer run the league, whether I'm around or not.
Admin panel

The solution

A web stats hub just for the CJ League, built on the FACEIT API, showing season data in a fast, visual and branded way. On top of it sits an admin layer that makes the platform self-sufficient.

Other design decisions:

  • Redis caching for instant loads. People open the site on their phones right after a match and have no patience for spinners.
  • Its own visual identity: dark theme, FACEIT orange and a clear type hierarchy. It's CJ League, not generic FACEIT.
  • A new-data badge in the bottom-right corner on mobile, within thumb reach.
  • Seasons as namespaces: history is preserved and every new season starts clean.
The solution

Design process

The project started pragmatically, with little wireframing before code. The loop was short and driven by the group's feedback:

Spot the pain → working MVP → group feedback → iterate → visual layer

Versions:

  • V1: a simple table of raw API data. It worked, but had no visual identity.
  • V2: FACEIT-inspired cards, with a dark theme, type hierarchy and orange as the accent color.
  • V3: pot filters, search, a map chart, the update badge and individual player pages.
  • V4 (planned): rank evolution charts based on historical Redis snapshots.

Success metrics

Quantitative metrics:

  • Load time (Vercel Analytics / Lighthouse). Baseline: over 2 s hitting the API directly. Goal: under 500 ms with cache. Result: 274 ms.
  • Cache hit rate (Redis logs). Baseline: 0%, no cache. Goal: over 80% of requests. Goal met.
  • Matches indexed (FACEIT API). Baseline: 0. Goal: 76+ in Season 1. Result: 411 matches.
  • Players on the leaderboard (hub data). Baseline: 0. Goal: 28 to 40 active players. Result: 53 players.
  • Uptime (Vercel monitoring). Goal: 99%+. Result: 100%.

Qualitative metrics:

  • Organic adoption: players posting screenshots of the site in Discord without being asked.
  • Basis for decisions: the organizer used hub data to seed pots for the next season.
  • Post-match return: players opening the site as soon as a match ends.
  • Operator autonomy: the admin panel was used without calling me.
  • Feature requests: people asked for rank evolution and per-match history.

Results & learnings

What worked:

  • Cache as UX: the speed was noticeable right away, and the group started opening the site on their phones right after matches.
  • Admin panel as a product: the organizer updated data, created a new season and managed players with no technical help.
  • Its own identity: a CJ League branded platform made people prouder to be part of the league.
  • Data that sparks conversation: the leaderboard became the reference in Discord and replaced the hand-made tables.

What I learned:

  • Rank history has to be planned from day one. Snapshots need to be saved before anyone needs them.
  • Documentation inside the product beats an external README. The panel guide actually got used.
  • Performance is a product feature. Redis was a UX decision as much as an engineering one.

Next steps:

  • Weekly rank evolution chart, from Season 2 on
  • Profile page with career history across seasons
  • Automatic Discord notifications via webhook when new data comes in
Next project

Product Tiles: the Shop's component system