Case studies

Case 01 · Smart TV and phone web

Phynd Games

A cloud game-streaming app for smart TVs, controlled with a TV remote or a gamepad, with a touch version for phone browsers.

Role
UX & Platform Engineer: co-designed the TV app with Phynd's graphic designer, and built it
Timeline
February – November 2026
Platform
Smart TV web app (app.phynd.games), gamepad + TV remote; phone web (play.phynd.games), touch
Team
Engineering team of 8, plus Phynd's graphic designer
Scope
10-foot UI, spatial navigation, motion, TV performance, in-game activity detection, phone layouts
Launch animationLogo intro on launch, followed by the transition to the first screen.

Overview

Phynd is a cloud game-streaming platform for smart TVs, with no console and no download. I co-designed the TV app with Phynd's graphic designer and built it: the launch animation, browsing, search, rankings, leaderboards, the profile picker, and the activity detection that times in-game ads. On the phone web app I built the touch layouts for the home and game-details screens and the loading countdown.

Home: featured gameFeatured game with title logo over key art, one genre and ESRB line, and two primary actions. Type and targets are sized for viewing at 3 m.

Constraints

  • Input. A D-pad on a TV remote or a gamepad is the only input. Part of the catalogue is playable with the remote alone, listed under "Play with your TV remote."
  • Hardware. Smart TVs run low-power SoCs with little GPU power and memory, and the menu has to leave headroom for the video stream. Holding 60fps on that hardware set the rules under Rendering performance.
Launch animationAnimated PHYND BETA wordmark shown on launch, before the first screen.
Profile pickerTwo targets, Guest and Add account. Guests can play without creating an account.

10-foot UI

The UI is read from about 3 m. Critical content stays inside an overscan-safe area, and the type scale uses heavy titles, short metadata and almost no body text.

The home screen opens with a full-bleed hero carousel: title logo over key art, one genre and rating line, and Play and More Info. Rails follow: PHYND Top 10 with large rank numerals, Play with your TV remote, New on Phynd and Featured Games. The dark navy background keeps artwork saturated in a dim room and leaves the purple focus ring as the most saturated element on screen.

Featured carouselFeatured games rotate on a timer; pagination pills show position. The rest of the screen is static during the change.
Featured game, detailTitle logo, one metadata line and two actions.
Primary actionsPlay and More Info buttons with a high-contrast focus state.
Top 10 railRank numerals rendered behind the card artwork.
Rail focus stateThe focused card scales up, gets a focus ring and shows its title. Unfocused cards do not change.
Remote-only games bandA band listing games playable with the TV remote alone, no controller required.
Remote-only games band, detailGames playable with a TV remote only, grouped in one band.

Spatial navigation model

I based the navigation on how console games handle a controller. Two buttons do most of the work:

  • Select activates whatever is focused.
  • Back cancels: it closes a pop-up, drops a selection, or moves up one level.

Every focusable element has x/y coordinates measured on screen at runtime. A D-pad press or an analog-stick push searches for the nearest focusable element in that direction by Euclidean distance, first inside the current container (the sidebar, the hero, a rail or a grid), then across containers. When a resize shifts the layout, focus still moves to the element the player sees in that direction.

  • Cards scale up and show a focus ring and their title when focused.
  • Sidebar stays collapsed to icons while browsing, and expands with labels when focus moves left.
  • Search uses an on-screen A–Z / 0–9 grid. Suggestions and result rails below it update on each key press.

Game Rankings, Leaderboards and the profile picker use the same model.

Horizontal rail navigationEach D-pad press moves focus one card and scrolls the rail, with a short eased transition.
Focused cardScale, focus ring and title label, animated on transform and opacity only.
Sidebar, collapsedIcon rail with Home, Search, Game Rankings, Leaderboards, Exit App and profile. Expands when focus moves left.
Sidebar expand and collapseThe sidebar expands on focus-left and collapses on focus-right in a single transition.
Sidebar, expandedMoving focus left expands the icon sidebar with labels; moving right collapses it.
On-screen keyboard inputEach key is a focusable node in an A–Z / 0–9 grid; suggestions update below as keys are entered.
On-screen keyboard inputEach key is a focusable node in an A–Z / 0–9 grid; suggestions update below as keys are entered.
SearchOn-screen A–Z / 0–9 key grid in place of a keyboard, with suggestions and rails below.
Search with a partial querySuggestions update on each key press, so a title can be selected before it is fully typed.
Ranking period tabsAll Time, Monthly and Weekly tabs replace the data in place; layout and focus position do not change.
Leaderboard period tabsSame tab component and behaviour as Rankings.
Rankings tablePlays, Players and Hours played per game, with the focused row highlighted.
Rankings side cardSelected game’s rank and longest streak, plus the next action: "Press OK to view the game."
Game RankingsTime-range tabs, top-five tiles and a stats table of play data.
LeaderboardsWeekly, Monthly and All Time standings, with a side card prompting guests to create an account to see their rank.
Profile selectionFocus moves between Guest and Add account, then into the app.
Guest rank cardShown to guests: creating a free account shows their own rank.

Rendering performance

A focus change that triggers layout runs smoothly on a laptop and drops frames on a TV. To hold 60fps on the slowest supported TV:

  • Compositor-only animation. Focus, rail scrolling and the sidebar animate only transform and opacity, so no frame needs layout or paint.
  • One transform per rail. A rail scrolls as a single transformed element, and DOM reads and writes are batched to avoid forced synchronous layout.
  • Scoped re-renders. A focus change re-renders two cards: the one losing focus and the one gaining it.
  • Virtualised rails. The first render creates only the cards on screen, and images load as rails approach the viewport.

The home screen's first render completes in under 200 ms.

Vertical navigation between railsMoving down scrolls the next rail into view, keeping the focused card on screen.

Motion

Animations confirm a key press, show where focus moved, or play the launch logo. The hero carousel advances on a timer long enough to read each title. Cards have no parallax and no bounce, which keeps the number of simultaneous animations, and the GPU cost, low.

New on Phynd railAll rails share one layout and one focus behaviour.

Activity detection

A game session can show a banner ad, and it should only appear when the player isn't playing. The TV app classifies each moment of a session as gameplay, paused, cutscene or idle, on the TV itself, from the stream's video and audio and the player's input. I designed and built the detector and the rules that time the banner.

  • Input. Key, remote and gamepad input reset a quiet timer. Analysis starts only after 5 seconds without input, so nothing runs during active play.
  • Video. Twice a second, the current stream frame is drawn into a 32×18 canvas and converted to luma. Each pixel is compared with the previous sample, and differences below the codec-noise floor are ignored. The score combines the share of changed pixels with how much of that change forms one connected region. A camera move in a cutscene changes one large region; menu animations and particles change scattered pixels.
  • Audio. A Web Audio analyser reads the stream's sound without affecting playback and flags dialogue: sustained energy in the speech band.
  • Decision. Every 5-second window compares its motion with the session's own baseline. A cutscene needs at least 7 of 10 samples to agree. Otherwise the window becomes paused (pause pressed), gameplay (input in the last 2 seconds) or idle.

The states have a priority (cutscene, paused, gameplay, idle) and a 1-second hysteresis, so the state doesn't flicker between samples. The banner is hidden during gameplay and shown in the other three states; once shown it stays for at least 15 seconds, and it waits 2 minutes before showing again. A long cutscene also resets the idle timer that ends inactive sessions. If a TV blocks reading the video frame or the audio, that signal drops out and the others keep working.

From stream frame to signalA camera pan changes 242 of 576 pixels in one connected region (signal 0.40); pause-menu particles change 67 scattered pixels (signal 0.07).
90 seconds of one sessionEight of ten votes confirm a cutscene at 22 s. The banner stays up its 15 s minimum, then the 2-minute cooldown keeps it hidden through the pause and idle that follow.
Four states in priority orderA higher-priority state takes over at once; an equal or lower one needs 1 s in the current state, and paused to idle needs 20 s of quiet.

Phones

Phynd also runs in a phone's browser at play.phynd.games, with a search bar fixed at the top and a dock fixed at the bottom. Both take height away from the page, so the home and game-details screens needed their own layouts for touch phones.

  • Upright. On short phones the featured slide was shorter than its own content, and the game logo slid under the search bar. The slide's minimum height is now the sum of its parts: logo, synopsis and buttons.
  • Sideways. A phone held sideways leaves about 230–260 px between the search bar and the dock. When the screen is wider than it is tall and under 500 px high, home and game details switch to compact layouts that keep Play now above the dock. The check reads the layout viewport, so opening the on-screen keyboard on an upright phone doesn't trigger it.
  • Descriptions. Game descriptions are clamped to three lines. View more appears only when the text overflows, with a 44 px touch target.
  • Loading. While a game starts, one countdown covers the pre-roll ads and the server warm-up, which is estimated from the server tier. Past the estimate it shows 0:00 and "still preparing" instead of restarting.
  • Branding and ads. The Phynd Beta wordmark sits on the dock, the landing page and sign-in, aligned to the 16 px content edge. On touch screens the ad's mute button is 48 px tall and pulses three times once muted, with no pulse under reduced motion.
Phone: homeSearch bar on top, featured game, and the dock with the Phynd Beta wordmark aligned to the 16px content edge. The slide is never shorter than its own content, so the logo stays below the search bar on short phones.
Phone: game detailsThe description is clamped to three lines, with View more shown only when the text overflows.

Outcome

The beta launched in May 2026 for Samsung TVs in the US. Phynd is now live on Samsung, LG, Fire TV and Vizio TVs.

  • The home screen's first render completes in under 200 ms.
  • A player gets from the home screen to a loading game stream in under 5 seconds.

I owned both the design and the implementation, so focus behaviour was tuned in code on the slowest supported TV.

Case 02 · Live data, web

CNN Election Center

The live results frontend for CNN's election coverage, rebuilt for the 2024 US election and still in production.

Role
Senior Frontend Engineer, data-visualization team
Timeline
Built for the 2024 US election; still in production
Platform
Web, desktop and mobile (cnn.com/election; captures from the 2026 midterms)
Collaborators
CNN's design and product teams
Scope
Frontend rebuild, UI refresh, motion, results-map interactions, page performance
Chamber switch transitionThe map recolours in place when switching between Senate, House and Governor.

Overview

CNN's Election Center is the live results page for election nights: uncalled races, a national map, the balance of power, a forecast and an index of every state, all updating live under election-night traffic.

For the 2024 election, the data-visualization team, CNN's designers and the product team rebuilt the election screens. I owned the HTML and CSS in the Svelte component system for elections, assembled the full pages, and implemented the motion with the design team. The screens here are from the 2026 midterms, running on the 2024 rebuild.

First screenKey uncalled races, the national map and Senate balance of power.

Constraints

  • No content could be removed. Every race, number and label is required, so colour, shade and position carry as much of the information as possible.
  • Live data. Results change all night, and values update in place without moving the layout.
  • Traffic. Election-night traffic is very high and spiky, so page weight and server load matter.

Visual encoding

Party colour is the main colour signal on a dark navy page, and every module uses it the same way:

  • Party colour fills the map, the candidate bars and the balance-of-power bar.
  • Shade separates leading (lighter) from projected (full strength).
  • Hatching marks flipped seats, and a check mark marks a projected winner.

Small states such as Rhode Island, Delaware and DC are drawn as bubbles off the coast so they can be read and clicked.

National results mapParty colour for the result, lighter shade for leading vs. projected, hatching for flipped seats, and bubbles for small states.
Balance of powerStacked bar with a control marker; legend for flipped and not-up seats below.
Map hover stateHover highlights one state; the rest of the map is unchanged.

National results map

The national map uses MapKit geometry and has a Senate / House / Governor switcher. Switching chambers recolours the map with a short transition, so readers see which states changed. Beside it, the balance-of-power card shows chamber control as a stacked bar with a control marker, and the CNN Sightline card summarises the forecast.

Chamber switcherSegmented control for Senate, House and Governor; switches the map in place.
Map: HouseHouse results on the same map, using the same colour encodings.
Map: GovernorGovernor results with the same colour, shade and hatching rules as Senate and House.
Forecast summary cardSightline forecast summary with one link: "See what’s driving it."

State drill-down

Clicking a state zooms the map to county level and opens a state results panel with the projected winner, candidate rows and a county table. The state stays in view while the counties load, and the back arrow plays the zoom in reverse.

State zoom transitionThe map zooms from national to county level while the results panel opens.
State results panelProjected winner, then candidate rows with percentage, votes and incumbent marker.
Results by countyCounty results table accompanying the county map.
State viewCounty-level results after the zoom; the state panel lists the projected winner first.

Motion and performance

  • Techniques. I picked the technique for each transition: CSS transitions, CSS keyframes, the Web Animations API, requestAnimationFrame loops, and FLIP (First, Last, Invert, Play) for elements that move to a new position in the layout.
  • Animated properties. Every animation changes only compositor properties (transform and opacity), which the browser runs on the GPU without layout or repaint. The map zoom and live updates hold their frame rate on mid-range phones.
  • Live data. I replaced polling with Server-Sent Events (SSE), which cut data traffic and server load.
  • Page weight. Fully server-rendered pages sent the same state map's markup two or three times. I moved them to selective SSR and loaded the large SVG maps from the CDN, where the browser caches them. Ad slots reserve their space, so ads load without shifting the results. Initial page load dropped by over 70%.
Page scrollScroll from live results through analysis and data sections.

Mobile layout

On mobile, the modules stack in one column in the same priority order as desktop.

Mobile, first screenKey races and the balance of power at the top of the scroll.
Mobile scrollSingle-column layout in the same order as desktop.
Mobile, full pageThe desktop modules stacked in one column, in the same priority order.

Outcome

The rebuilt Election Center ran CNN's 2024 election-night coverage and is still in production for the 2026 midterms.

  • Initial page load reduced by over 70% on election pages that repeat the state map.
  • Ads load without shifting the results.

Case 03 · Phynd · Internal tools, full stack

Titan

Phynd's internal console for feature flags, rollouts and controller maps, and the backend that enforces its rules.

Role
UX & Platform Engineer: designed the console and built its front end and backend
Timeline
February – November 2026
Platform
Internal web console, plus the flag SDK and TV client it drives
Team
Phynd engineering team of 8; used daily by about 20 people at Phynd
Scope
Feature flags (data model, evaluation, delivery, authoring UI), rollout board, controller map approvals
Flags tableStat tiles summarising all flags, above the flags table.

Overview

Titan is Phynd's backoffice console for enabling features, rolling them out, and setting which game controllers work on which TVs. A flag change alters every Phynd TV app, and an approved controller map changes how a player's buttons behave.

I designed the console and built the systems behind it: the flag data model, evaluation, delivery to TVs, the rollout board, and the controller mapping flow. The backend enforces the safety rules, and the interface shows them.

The first version (the purple screens) used React 19, Vite, TanStack Router and Query, Tailwind with shadcn, and Recharts. The newer console (the dark screens) moved to Base UI, with Clerk auth, a cmdk command palette and Ask Titan, an AI copilot over MCP.

Constraints

  • Production impact. A wrong click can enable an unfinished feature on every TV, so recovery has to take one action.
  • Concurrent editors. People, the API and the AI copilot can edit the same flag at the same time.
  • Warning fatigue. Confirmations are limited to the actions that need them, so people don't learn to click through them.
Stat tilesCounts across all flags, shown above the table.
Flag filtersSearch, filters and the Table/Board toggle.

Flag data model

Keys are typed by prefix, and the backend enforces rules per type: feat_ expires within 90 days, exp_ within 30, ops_ is for operational switches and kill_ for emergency off-switches.

Every flag has a risk tier (T1 to T3), an owner and an expiry. The new-flag dialog requires them at creation, along with the starting rung, expected impact, scope, a rollback plan and known side effects. It is laid out as a short pre-release checklist, so old flags can be found and retired later.

The Flags page has a Table / Board toggle, Groups by initiative, reusable Segments, and History.

New flag formType, name, starting rung, risk tier, owner, expiry, impact, scope, rollback and side effects, all required at creation.
New flag dialogRisk tier, owner, expiry and rollback plan are required fields.

Flag evaluation and delivery

A flag's page shows its status as a release ladder (Self → Engineering → Phynd → Staged → Public), with a kill switch per environment. The targeting rules editor has a Visual mode and a Raw JSON mode that shows exactly what the SDK receives.

  • First matching condition wins, in the order shown on screen.
  • Deterministic bucketing with murmur3, using separate seeds for the traffic split and the treatment split. A player always lands in the same bucket, and the two splits are independent.
  • Safe defaults. A killed flag serves its default, an archived flag serves control, and a failed evaluation serves the safe default.

Each publish writes an immutable ruleset to the CDN and moves a "current" pointer to it. TVs read that one public file and evaluate flags locally. With no live flag server, delivery cost stays flat per TV, and a revert moves the pointer back. The TV SDK polls for rules every 5 minutes, checks the kill list every 30 seconds, and keeps the last good ruleset when the network drops.

Flag detail, full pageLadder, environment cards and targeting rules editor. Rules are evaluated top to bottom.

Guardrails

Most guardrails only appear when they block something.

  • Compare-and-swap saves. If the flag changed during your edit, the save is rejected with a plain-language conflict message.
  • Publish review lists every unpublished change as one readable line, with whitelist values hidden.
  • Kill publishes immediately. The dialog stays open until the server confirms the write.
  • Delete only after archive. A flag must stop serving before it can be deleted.

Every change writes an audit row: who made it, from which surface (the UI, Ask Titan or the API), and the before and after values.

Release ladderSelf, Engineering, Phynd, Staged, Public: who can see the flag at each rung.
Environment cardsSeparate staging and production cards, each with its own kill switch.
Flag detailRelease ladder (Self → Engineering → Phynd → Staged → Public) and separate staging and production cards, each with its own kill switch.

Rollout board

The first board was a kanban: Draft, Ramping, Live, Stale and Archived.

  • No optimistic moves. A move waits for the server and ignores stale responses. If it fails, the card stays in place and shows an error.
  • Traffic tint with fallback. Cards are tinted by hourly traffic, and show "unavailable" if the rollup fails.
  • Days in stage on each card, so a rollout stuck in Ramping is visible.

The newer releases view uses the ladder rungs as columns, plus an Attention column for drift, missing owners and blocked rollbacks. A card is marked stuck after 24 hours in one rung.

Promoting past engineering requires a written attestation, green CI, a soak time set by risk tier (24 hours for T2, 48 for T3), and an approver who isn't an author, with two approvers for T3. Demote, rollback and kill have no gates.

Flags boardFlags grouped by lifecycle stage.
Rollout board, v1Draft, Ramping, Live, Stale and Archived columns, always rendered, including when empty.
Flag history, v1First version of the change log, replaced by the day-grouped history in the current console.
Flag historyChanges grouped by day, with author, source surface, and before/after values.
Flag groupsFlags grouped by initiative.
SegmentsReusable audience definitions referenced by targeting rules.

Controller map approval

Gamepads report their buttons differently from one model to the next. A map converts raw button indices into 17 standard slots, with optional D-pad hat and trigger axes and a deadzone. Pads that need no map get a Validated record.

Mapping starts on the TV: the player maps the pad slot by slot, and the TV shows a code and QR code valid for 10 minutes. The operator's approve page:

  • strips the code from the URL and shows a countdown;
  • asks one question: "Does the TV show this code?";
  • shows a per-slot diff against the current map;
  • labels the button with the result, for example "Approve and replace".

Approval is a single version-guarded transaction, and a request locks after 5 failed attempts. Each record keeps its previous version, so a restore is one step. Each controller's page shows a gamepad diagram, the input-slot table and a How TVs read it panel. TVs fetch maps only for pad names they haven't seen, cache them, and apply a map only when the pad id and the button and axis counts match. Ask Titan can read controller data but can't approve or restore maps, because that needs a person checking the TV.

Gamepad diagramInputs covered by the map vs. unmapped inputs.
Input slot tableRaw button indices mapped to standard slots; required slots are face buttons, select/start and D-pad.
ControllersSupported controllers with platform chips and stats. Filter state is stored in the URL.
Controller mapGamepad diagram of mapped and unmapped inputs, slot table, "How TVs read it" panel and the stored record.
How TVs read itHow a TV matches and applies this record.

Outcome

  • 200+ flags, managed daily by ~20 people across Phynd.
  • Flag updates reach players' TVs in 15 seconds on average, and in 5 minutes in the worst case.
  • All flags are served from one public CDN file, with no live flag server.
  • The team uses the controller flow to validate controllers across the supported TV platforms.

Every state the UI shows (a killed flag, a moved card, an approved map) is confirmed by the server before it appears.

Case 04 · Phynd · Data & discovery

Recommendation engine

A daily batch that turns play sessions into engagement labels, game neighbours and a popularity score, with search integration and an insights page in Titan.

Role
UX & Platform Engineer: designed and built the engine, the search integration and the insights page
Timeline
February – November 2026
Platform
Daily batch job, Phynd search, and an insights page in Titan
Team
Phynd engineering team of 8
Scope
Engagement labels, game neighbours, popularity score, search integration, insights dashboard
Engine insightsLove vs. bounce lift bars, engagement shares and a similarity histogram.

Overview

Phynd's catalogue is too large to browse with a TV remote, and every irrelevant suggestion costs the player D-pad presses. I designed and built the recommendation engine end to end: a daily batch that turns play sessions into engagement labels, game neighbours and a popularity score; the search integration; and an insights page in Titan.

Constraints

  • Session data only. There are no ratings, so liking has to be inferred from launches and session lengths. A retry after a dropped connection looks like a replay, and a ten-minute session means different things for different games.
  • Explainability. Co-play finds useful links and wrong ones, so every recommendation needs a stated reason.

Engagement labels

Each player–game pair gets a label from the last 28 days of sessions, with technical retries excluded:

  • 3 or more launches: liked.
  • 2 launches: liked if long sessions outnumber short ones, otherwise neutral.
  • Anything else: neutral if long sessions outnumber short ones, otherwise bounced.

"Short" and "long" are each game's own 25th and 75th percentile session lengths. Games with fewer than 30 completed sessions use platform-wide percentiles.

Session labels against per-game percentilesThe same 6-minute session is above Tile Drift’s p75 and below Ashen Crown’s p25. Launch count and the long/short mix then label each pair liked, neutral or bounced.
Session length, full pagePlay time for every game in the catalogue.

Game neighbour graph

For each pair of games, the engine computes lift: how much more likely a player is to like game B after loving game A, compared with how likely anyone is to like B.

lift = P(liked B | loved A) / P(liked B)

Lift corrects for popularity. Raw co-occurrence counts would rank the most popular games first for every game. A second table applies the same calculation to bounced A → liked B.

A player's list is built from their liked games. A neighbour needs at least 2 co-players, each candidate keeps its highest lift, and the top 10 form the list. Players with no history get a popularity-based list with at most 1 game from the global top 5.

A second graph, player-to-player (Jaccard similarity over liked games), drives the screen shown after a stream ends, based on what similar players went on to play. The game-to-game graph drives related games in search. The batch runs daily at 06:45 UTC with date-partitioned, idempotent output.

Lift-weighted neighbour graphEdge width shows lift: 68% ÷ 20% = ×3.4. The second view shows what players who bounced went on to like.

Popularity score

The score uses a 14-day window with recency decay over about a week and weights five signals: replays 0.25, hours played 0.22, favourites 0.20, plays 0.18 and active players 0.15. Replays weigh most because they show the player came back.

Each signal is log-normalised against its own 95th percentile, so one outlier doesn't compress the rest of the catalogue. A confidence term pulls new games toward a neutral 50 until they reach about 50 plays and 3 days of age.

Confidence blending for new gamesTwo new games start at a neutral 50 and reach their raw scores (86 and 24) only after 50 plays and 3 days.

Insights page

The insights page in Titan has three views: Session length (the raw data behind the labels), Popularity, and Engine insights, with love vs bounce lift bars per game, engagement shares and the player similarity histogram.

The API runs its three queries in parallel and caches results until 07:00 UTC, after the batch finishes. Pairs with fewer than 30 co-players are hidden, because a lift from a handful of players looks the same on a chart as one from thousands.

Session lengthPlay time per game; input to the engine’s liked, neutral and bounced labels.

Outcome

  • Related-games suggestions raised average sessions per player from 1.2 to 1.5.
  • Players who open a recommended game have longer sessions and play more games per session.
  • Stakeholders use the insights page to present platform-wide data to potential investors.