Case Studies

Linkudo

Technical architect and sole developer, rebuilding a classic Flash word association game as a modern, mobile‑first web application for contemporary browsers and devices.

Screenshot of the Linkudo website; part of John Kavanagh's selected project work.

In Brief

Created by Tony Moriarty, Linkudo ("Link you do") is a word association game in which players connect two words through a sequence of related, rhyming, and thematic links in as few steps as possible. Originally developed as a Flash game in the late 2000s, Linkudo appeared in publications including The Times, but was left behind as the web moved away from Flash.

In 2025, I was commissioned to rebuild it for the modern web, preserving Tony's original concept.

My Role

As technical architect and sole engineer, I was responsible for the end‑to‑end technical implementation of the modern Linkudo application. Working from client‑provided visual designs, I built the Next.js front end, supporting services and tooling, data integration, responsive gameplay, player preferences, social sharing, and production deployment. The result preserved the spirit of the original game whilst making it viable for modern web and mobile users.

Technologies

linkudo.com
  1. Next.js & React
  2. TypeScript & SCSS
  3. Supabase & PostgreSQL
  4. Node.js & Python
  5. Redis

In Detail

Bringing Linkudo back to the web was not a conventional website redevelopment or straightforward rewrite. The original Flash‑based game belonged to an earlier generation of web technology and could no longer simply be brought back online, with the original codebase no longer feasible to build upon. The new version therefore required a ground‑up technical implementation capable of preserving the character of Tony's game whilst adapting it to contemporary browsers, mobile devices, and expectations around web performance and usability.

The concept and gameplay remained Tony's; my responsibility was to determine how these could be translated into a maintainable modern web application and then deliver that technical solution.

This created two distinct technical challenges:

  • Rebuilding the game system:

    creating the application architecture and supporting tooling required to operate Linkudo as a contemporary daily web game.
  • Delivering the player experience:

    developing a fast, responsive, themable Next.js and React front end that let players solve puzzles, track performance, persist preferences, and share results.

Game Configuration Generation

Each day, Linkudo presents players with a new challenge. I developed a Python‑based generation process to prepare these daily game configurations in advance, performing the computationally intensive work outside of the live application rather than generating challenges in response to player requests.

Precomputing the configurations allowed future games to be prepared ahead of time and kept the more complex processing out of the player‑facing application. The live game could therefore retrieve a prepared configuration when required, keeping the gameplay experience fast and responsive.

Delivering the Game Experience

The player‑facing application was built with Next.js, React, TypeScript, and SCSS, supported by a wider back‑end architecture using Node.js, Supabase/PostgreSQL, and Redis. Together, these provided the foundations for a fast, responsive game experience whilst supporting player state, preferences, results, and the wider functionality around each daily game.

Working from the client's visual designs, I developed a reusable component system around the core word‑linking experience, adapting the game for modern browsers, touchscreens, and different viewport sizes. The interface was deliberately kept simple and responsive, allowing the gameplay itself to remain the focus.

Customisable Player Preferences

Linkudo supports five selectable themes, allowing players to personalise the game without changing its underlying mechanics. I implemented the theming and preference system so that player choices persist between visits, with theme usage also tracked to understand which options proved most popular with players.

A screenshot of the Linkudo game, displaying the default dark blue theme, and showing the first step in the game.A screenshot of the Linkudo game, displaying the optional light blue theme, and showing the second step in the game (having chosen 'Arranger' in the first step).A screenshot of the Linkudo game, displaying the optional pink theme, and showing the third step in the game (having chosen 'Arranger' in the first step, and 'Engineer' for the second step).A screenshot of the Linkudo game, displaying the optional green theme, and showing the fourth step in the game (having chosen 'Arranger' in the first step, 'Engineer' for the second step, and 'Agitator' for the third step).A screenshot of the Linkudo game, displaying the optional sage theme, and showing the fifth step in the game (having chosen 'Arranger' in the first step, 'Engineer' for the second step, 'Agitator' for the third step, and 'Campaign' for the fourth step).

Automated Social Share Image Generation

When a player completes a game, Linkudo can create a branded social share image reflecting that day's challenge, the player's result, and their selected theme. Supporting every possible combination and permutation manually would have created a repetitive production task, so I built a standalone Node.js service to automate the process.

Using React and Puppeteer, the service generates the required image variants from reusable components, keeping them visually consistent with the game itself and ready for use when players share their results.

A grid of share images for Linkudo, showing all thirty different possible combinations of steps and themes for each individual game.

From Beta to Launch

The rebuilt Linkudo progressed through private beta before launching publicly in 2025. More than 2,000 games were played on the first day of beta, providing an immediate real‑world test of the application and supporting architecture, with initial player feedback strongly positive.

The launch brought Tony's original game back to the web after an absence of almost two decades, but for a very different generation of casual game players. Where the original had been created in the Flash era and designed to be played on desktop computers, the new Linkudo was built around responsive, touch‑based interaction and the expectation that many players would play on their phones.

Whilst the concept remained the same, the technology and experience around it had been rebuilt for a fundamentally different web.


Looking for
technical direction?

For platform changes, recovery work, and high‑stakes delivery, I can help define the approach and stay hands‑on where the hard problems are.