top of page
WorkinGames_Background.png

WorkinGames

Full-stack game development job board

WorkinGames_FrontPage_Large.png
Live product!

Introduction

Project details

Workingames is a live job board for game developers, built as a full-stack product with a public website, custom search, backend APIs, automated job data pipeline, payment flow, internal audit tools, and monitoring systems.
 

The project started from a real problem I noticed in the game industry: job listings are spread across many studio websites, expire quickly, and are often difficult to search through in one place. Workingames solves this by collecting, validating, organizing, and publishing game development jobs in a focused platform.

  • Role: Founder / Full-stack Developer

  • Type: Live web product

  • Frontend: Next.js, React, TypeScript

  • Backend: Supabase, API routes, Google Sheets API

  • Automation: Playwright, Node.js scripts, validation pipeline

  • Integrations: Stripe, Zepto/Zoho Mail, Google indexing 

  • Status: Live product

VISIT WORKINGAMES

Overview

Workingames is a live game development job board supported by a recurring automation pipeline. The public website lets users search, filter, and browse game industry jobs, while the backend collects jobs from studio career pages, validates them, extracts structured details, removes stale listings, and syncs approved jobs into the live database.
 

The system is split into four main parts: job sources, automation pipeline, live product, and internal tools.

  • Master source list - Studios, career URLs, status, extractor targets

  • External websites - Career pages, job widgets, ATS boards

  • Scanner - Finds possible job links

  • Validator - Confirms real job detail pages

  • GameDevCheck - Filters for game development roles

  • Detail Extractor - Extracts role, seniority, location, and work mode

  • Supabase - Stores live job and promotion data

  • Search API - Handles filters, relevance, related searches, and pagination

  • Website - Job search, filters, job pages, and saved alerts

  • Audit dashboard - Shows failed, missing, or uncertain pipeline stages

  • Monitor app - Tracks posts, link checks, and operational tasks

  • Cleanup tools - Remove stale jobs and help discover new studios

USER EXPERIENCE

Focused job discovery

Workingames is designed around fast job discovery. The goal was to help game developers search through relevant roles without mixing them with generic tech listings. The public site focuses on clear job cards, useful filters, dedicated job pages, and enough structured information for users to quickly decide whether a role is worth opening.

Search and filters

The search page supports role, location and studio search with discipline filters, seniority filters, work-mode filters, sorting, pagination, related-search suggestions, and saved searches.
 

The important challenge was making the filters feel useful without overwhelming the page. To do that, the frontend relies on structured job fields from the backend, such as role, studio, location, seniority, work mode, discipline, promotion status, and posted date.
 

This also makes the search experience more flexible than a simple keyword list. Users can start broad, narrow down by discipline or work mode, and still discover related roles through suggested searches.

WorkinGames_Search.png
WorkinGames_Filters.png
Job detail pages

Each job has its own detail page with structured information and a clear apply link. This gives users a cleaner reading experience than opening everything from a list view. It also supports search visibility, because individual jobs can exist as dedicated pages instead of only being hidden inside search results.

WorkinGames_JobDetailPage.png

DATA PIPELINE

The biggest backend challenge was keeping the job board updated from hundreds of inconsistent studio career pages. I built a recurring data pipeline that scans career pages, finds possible job links, validates them, filters for game development roles, extracts structured details, handles uncertain cases, and syncs approved jobs into the live site. The diagram below shows how external job sources become reviewed, structured listings on the live website.

Source and scanning

The pipeline starts from a source list of studios and career page URLs. The scanner opens these sources, handles normal websites, ATS boards, job widgets, pagination, and JavaScript-loaded content, then writes candidate job links into the scan results.

Each found link is tracked with metadata such as studio, job URL, run ID, first seen, last seen, and missed count so the system can tell whether a job is new, still active, or becoming stale.

Validation and filtering

The pipeline does not publish every scanned link automatically. The validator first checks whether a link is a real single job detail page. After that, GameDevCheck filters out non-game roles, unrelated industries, generic corporate jobs, expired pages, and uncertain cases.

Rows that are blocked, unclear, or missing important signals are held for manual review instead of being pushed directly to the live site.

Extraction, cleanup, and sync

After a job passes validation, the detail extractor turns the page into structured data such as role, seniority, location, and work mode. Special/API sources can also enter the pipeline through the URL-specific extractor.

At the end of the run, cleanup tools remove stale or orphaned rows, studio import tools add new source candidates, and the sync API moves approved jobs into Supabase for the public website.

SEARCH, SYNC & BUSINESS LOGIC

Search API

The public job board is powered by a custom search API connected to Supabase. It handles role taxonomy matching, relevance sorting, filters, facet counts, related-search suggestions, promoted ordering, pagination, and search correction, making the search experience more useful than a simple keyword query.

Sync Workflow

Validated jobs start in Google Sheets after passing the pipeline, then the sync workflow moves approved rows into Supabase for the public site. It updates existing jobs, removes expired jobs, handles promoted listings, queues Google indexing events, and keeps the live website connected to the internal review pipeline without manual copying.

LinkedIn Post Generation

I also built a content automation workflow for LinkedIn posts based on current job data. The system can search jobs by studio, select which roles to include, generate post text and images, and let me review apply links before publishing, turning the job board data into reusable marketing content while still keeping a manual review step.
WorkinGames_LinkedInPosts.png

Payments and alerts

Workingames includes a Stripe-based purchase flow for enhanced listings and recommended tags. Paid submissions are written into an approval workflow before publishing, and the site also supports saved search alerts where users can receive email updates when new jobs match their search.
WorkinGames_PromotedJob.png

AUDIT & MONITORING TOOLS

Audit dashboard

I built an internal audit dashboard to inspect how each job link moves through the pipeline. It groups data by studio and link, shows which stage each job reached, flags missing or failed stages, and lets me close, reopen, watch, or add notes to problem items.
WorkinGames_Audit.png

Pipeline monitoring

The pipeline status parser turns raw log output into structured progress data. It tracks the current run, active stage, current studio, progress percentage, batch writes, recent errors, and remaining work, then writes that status to JSON and Supabase.

Mobile monitor app

I also built an Expo/React Native monitor app for operational tasks. It shows recent generated LinkedIn posts, related jobs, generated images, and includes a mobile review flow for checking whether apply links are still valid. It also allows me to follow the progress of each run and track errors on the fly.
WorkinGames_JobscanMonitor.png

Closing thoughts

Workingames helped me grow as a software developer because it forced me to work with real production problems instead of isolated exercises. The hardest part was not building one page or one script. It was connecting many systems together: a public frontend, search API, database, payment flow, job scanning pipeline, validation logic, manual review tools, sync workflow, and monitoring tools.

​

This project taught me how important it is to design for unreliable data, failed requests, expired links, duplicate entries, unclear edge cases, and long-term maintenance.

The development of WorkinGames will continue, not only in terms of adding more studios but also additional features, performance, UX and much more.

bottom of page