Build an FPL Data Dashboard: A Step-by-Step Spreadsheet Tutorial for Students

Stop losing points because of late injury news — build an FPL dashboard that pulls injury updates and FPL stats automatically

Students, tutors and lifelong learners: if you spend hours refreshing multiple sites to check injuries, form and ownership before setting your Fantasy Premier League (FPL) team, this tutorial shows how to build an automated spreadsheet dashboard that collects player and injury data, visualises trends and gives simple, explainable predictions for team selection.

What you'll build (and why it matters in 2026)

Outcome: a reusable Google Sheets or Excel workbook that

• imports FPL player & fixture data automatically;
• scrapes or ingests injury/team-news feeds (BBC-style roundups and official club updates);
• computes expected minutes and expected points for the next gameweek;
• flags injury-risk players and creates captain/transfer suggestions; and
• sends alerts when a prioritized player's status changes.

Why now (2026): public sports data availability and AI summarisation tools improved in late 2025 — but web platforms also tightened anti-scraping rules. That means the smart approach is to prioritise official JSON endpoints and sanctioned feeds, add lightweight parsing in the spreadsheet, and layer human verification for injury-sensitive decisions.

Quick tech choices (pick one)

• Google Sheets + Apps Script: easiest to share and automate for students; supports IMPORTXML + custom IMPORTJSON functions and timed triggers.
• Excel (Desktop/365) + Power Query: robust JSON handling and scheduled refreshes for advanced users and offline work.
• Python (Colab/Jupyter): best for advanced modelling and heavy scraping, but requires extra steps to feed results into a spreadsheet or dashboard.

Data sources & legal note

Reliable inputs for an FPL dashboard in 2026:

• Official FPL JSON endpoints (publicly-known bootstrap and fixtures endpoints) for player attributes, ownership, points and minutes.
• Fixtures API (for opponent, home/away, kickoff times and difficulty sequences).
• Team/injury news: BBC Sport roundups, club press releases, official club/team RSS feeds and verified journalists. In late 2025 many clubs offered structured press-release feeds or APIs; prefer these over broad scraping.
• Community datasets: trusted FPL community APIs and spreadsheets (use cautiously and verify).

Tip: respect robots.txt, API rate limits and copyright. Prefer official endpoints or explicit permission when pulling news content.

Step 0 — Plan your data model

Before any code or formulas, design the sheets you need. Keep it modular so students can reuse components for class projects.

• PlayersRaw — raw JSON dump of all FPL players.
• Fixtures — upcoming fixtures with home/away, difficulty and event (GW) id.
• InjuryNews — parsed lines of injury/team news with date, player_id, status (out/doubt/fit), source and raw text.
• Metrics — computed stats per player (minutes projection, xPts, form, ownership).
• Dashboard — visualisations, top picks, alerts and captain recommendation.

Step 1 — Import FPL JSON into a sheet

Use the FPL bootstrap endpoint (commonly available in the community). In Google Sheets you can use a small Apps Script IMPORTJSON or use Power Query in Excel to fetch and expand the JSON.

Google Sheets: Apps Script approach (simple)

Create a new Apps Script (Extensions → Apps Script) and paste this compact fetch function. This function grabs the bootstrap JSON and writes it into a sheet called PlayersRaw:

// Paste in Apps Script editor (Projects > Code.gs)
function fetchFPLBootstrap() {
  const url = 'https://fantasy.premierleague.com/api/bootstrap-static/';
  const resp = UrlFetchApp.fetch(url, {muteHttpExceptions: true});
  const json = JSON.parse(resp.getContentText());
  const players = json.elements; // players array

  const sheet = SpreadsheetApp.getActive().getSheetByName('PlayersRaw') || SpreadsheetApp.getActive().insertSheet('PlayersRaw');
  sheet.clear();

  // header
  const headers = ['id','first_name','second_name','team','element_type','now_cost','total_points','minutes','form','news','news_added','chance_of_playing_next_round','chance_of_playing_this_round'];
  sheet.appendRow(headers);

  players.forEach(p => {
    sheet.appendRow([p.id, p.first_name, p.second_name, p.team, p.element_type, p.now_cost, p.total_points, p.minutes, p.form, p.news, p.news_added, p.chance_of_playing_next_round || '', p.chance_of_playing_this_round || '']);
  });
}

// You can create a time-driven trigger to run this function regularly.

Set a time-driven trigger (clock icon) to run fetchFPLBootstrap hourly or every 3 hours depending on quota.

Excel Power Query (equally solid)

1. Data → Get Data → From Web → paste the JSON endpoint URL.
2. Transform JSON → convert to table → expand the elements array to pull player attributes.
3. Rename columns, change types and Load To → Table 'PlayersRaw'.

Step 2 — Ingest injury & team news

There are two reliable patterns for news:

1. Use textual fields inside FPL data — the JSON includes a short news field per player; often this carries concise injury notes and a news_added timestamp. This is the simplest start.
2. Supplement with official news feeds — BBC Sport team-news pages, club press releases or club RSS feeds. Prefer these official feeds over scraping entire web pages.

Parsing textual news in the sheet

In a Metrics sheet, create a column injury_flag that checks the player's news text. Example Google Sheets formula in column H, assuming the news text is in column G:

=IF(REGEXMATCH(LOWER(G2), "(out|unavailable|ruled out|injury|doubt|doubtful|suspended|suspension)"), "Out/Doubt", IF(G2="", "None", "Note"))

This quick text classification flags likely problems. For more precision, parse known patterns like "doubtful for" or dates in the news string.

Pulling BBC-style roundups

BBC Sport team news pages are a great human-verified source — they are updated frequently (the BBC article format is still widely used in 2026). Where the BBC provides an RSS or structured feed, import that. If not, use a permissioned approach or copy the important lines manually. The recommended approach for students is:

1. Subscribe to official club and BBC RSS/alerts for automated push updates.
2. Use Apps Script to fetch the feed URL and parse items into an InjuryNews sheet with columns: date, club, player_name_text, status, source_url.

Sample Apps Script snippet to parse a feed (pseudo):

function fetchRFCFeed(url, sheetName) {
  const resp = UrlFetchApp.fetch(url);
  const xml = XmlService.parse(resp.getContentText());
  // parse items -> write to sheet
}

Step 3 — Normalize and join datasets

Players from FPL are identified by id. Injury feeds usually give names. Create a small mapping table to match names to player_id using fuzzy matching if necessary.

• Use XLOOKUP (Excel) or INDEX/MATCH (Sheets) to connect news lines to player IDs.
• Where names differ (nicknames, accents), add alternate-name rows in a NameMap sheet.
• After joining, add a column status_source (FPL-news vs. BBC vs. club).

Step 4 — Compute projected minutes & expected points

Here we build a simple, explainable prediction model useful in class and for decision-making. Keep it transparent: avoid opaque ML black boxes for weekend decisions.

Core idea

Expected points for next gameweek (xPts) = expected_minutes_fraction × baseline_points_per_90 × fixture_factor × (1 - injury_penalty) + form_bonus

Fields to compute

• baseline_points_per_90 = total_points / (minutes / 90). (Use a small smoothing factor to avoid division by zero.)
• expected_minutes_fraction = probability_of_start * projected_minutes_if_start / 90. Estimate probability_of_start from recent starts, manager quotes and chance_of_playing fields.
• fixture_factor = opponent strength multiplier (1.0 baseline, >1 easier, <1 harder). Compute using opponent league goals conceded or FDR sequences.
• injury_penalty = mapping from injury_flag: Out/Doubt = 0.6–1.0 penalty; Note = 0.1–0.3; None = 0.
• form_bonus = short-term form (last 3–5 gameweeks average points scaled).

Sample spreadsheet formulas (Google Sheets)

Assume in Metrics sheet you have: total_points (col B), minutes (col C), minutes_last5 (col D), news_flag (col E), chance_of_playing_this_round (col F), fixture_factor (col G), form (col H).

// baseline points per 90
=IF(C2>0, B2/(C2/90), B2/90)

// prob_start (simple) - use chance_of_playing if numeric, else fallback to recent starts
=IF( ISNUMBER(F2), F2/100, MIN(1, (D2/450) + 0.2) )

// injury penalty mapping
=IF(REGEXMATCH(E2, "out|ruled out|unavailable|suspended"), 0.9, IF(REGEXMATCH(E2, "doubt|doubtful|injury"), 0.6, 0))

// expected minutes fraction
=prob_start * 70/90  // assume average starter plays 70 mins; fine-tune by position

// expected points
=baseline_pp90 * expected_minutes_fraction * G2 * (1 - injury_penalty) + H2

Interpretation

This simple xPts is explainable: it balances historical productivity with likely minutes and injury risk. Use it to rank players and inform captain choices.

Step 5 — Build the Dashboard (visual design)

Design a compact dashboard on a single sheet so you can see key decisions at a glance.

Suggested layout

• Top-left: Week summary (GW number, last update timestamp, number of injuries).
• Top-right: Captain recommendation tile (player with highest xPts and low injury_penalty).
• Left column: Top 10 xPts players (sortable) with sparkline recent form, ownership and cost.
• Middle: Injury alerts — players flagged as Out/Doubt with source and time.
• Right: Watchlist / transfer suggestions — differential picks with favourable fixtures.
• Bottom: Visualisations — bar chart of xPts by position, heatmap of fixture difficulty, and a time-series of your team's expected weekly score.

Spreadsheet features to use

• Conditional formatting to mark Out/Doubt in red, heavy ownership in amber for differential awareness.
• Slicers (Excel/Sheets) to filter by position or team.
• Pivot tables for aggregated ownership and points by club.
• Sparklines for mini-chart trends in the Top 10 list.
• IMAGE() in Google Sheets to show player photos (optional) via verified CDN endpoints.

Step 6 — Automation & notifications

Timely alerts are key. Use Apps Script triggers or Power Query scheduled refreshes to update your data. Add a notification if a player in your squad moves from "None/Note" to "Out/Doubt".

Google Sheets alert example (Apps Script)

function checkInjuryAlerts() {
  const ss = SpreadsheetApp.getActive();
  const sheet = ss.getSheetByName('Metrics');
  const data = sheet.getRange(2,1,sheet.getLastRow()-1,10).getValues();

  const watched = ['Player A','Player B']; // replace with your squad or watchlist column
  const alerts = [];

  data.forEach(row => {
    const name = row[0];
    const flag = row[4]; // injury_flag
    if (watched.indexOf(name) > -1 && flag.match(/Out|Doubt/)) {
      alerts.push(name + ' - ' + flag);
    }
  });

  if (alerts.length) {
    MailApp.sendEmail('you@example.com','FPL Injury Alert',alerts.join('\n'));
  }
}

Step 7 — Validate with BBC-style manual checks

Automated text parsing helps most of the time, but injury classification can be fragile. Use the BBC-style weekly roundup (or club press conferences) to validate high-impact calls. Add a manual review column verified_status where you or a teammate confirm the automation's classification.

Case study: the BBC's 16 Jan 2026 roundup noted some key absences and returns — for example, players returning from AFCON or being ruled out. Your dashboard should surface these updates and give you a single place to confirm them manually.

Step 8 — Advanced strategies & 2026 trends for students

Once the basic dashboard is running, try these advanced steps — perfect for coursework or a small group project.

• Ensemble predictions: combine the simple minutes-based model with a small logistic model that predicts starting probability from recent starts, manager rotation patterns and cup fixtures.
• Feature engineering: add opposition xG conceded, home/away boost, rotation risk (midweek European fixtures), and substitute appearance probability.
• Auto-summarisation (AI): use a hosted LLM to summarise long press-conference transcripts into a compact injury probability score — but keep the summary auditable and save the raw transcript.
• Ethics & legality in 2026: many clubs adopted structured feeds but tightened scraping restrictions in 2025. Always cite sources and avoid republishing copyrighted text; for class use, summarise and link to the official article.

Sample walk-through: how a late injury changes captaincy

Imagine your top captain candidate (Player X) has the highest xPts before Friday. Your automated feed pulls FPL JSON at 15:00 and finds Player X's news changed to "doubtful after afternoon training". Your sheet's regex flags it as Doubt and applies a 0.6 injury penalty, lowering xPts below your next best option (Player Y). Your Apps Script sends an email alert and the Dashboard captain tile now highlights Player Y.

This flow reduces the risk of losing points due to late changes — exactly the scenario that frustrates managers each Gameweek.

Testing and classroom exercises

For tutors: use this as a lab exercise.

1. Task 1 — Import FPL JSON and list the top 20 point-per-90 players.
2. Task 2 — Parse the news field for all players and make a confusion matrix vs. manual labels.
3. Task 3 — Build two captain recommendation strategies (highest xPts vs. lowest injury risk × xPts) and backtest over the last 12 gameweeks.
4. Task 4 — Present findings; discuss data quality, bias (e.g., players who play more minutes get better baseline metrics), and ethical scraping.

Troubleshooting common problems

• Empty JSON or broken endpoint: check the URL, network, and whether the platform changed endpoints. Community forums often post updates when endpoints are moved.
• Rate limits: reduce fetch frequency, cache results, or move heavy fetching to a server script with proper API keys.
• Parsing inconsistencies: name mismatches are common. Build and maintain the small NameMap and comment mapping choices for reproducibility.
• False positive injuries: short news strings can be ambiguous. Use a conservative penalty and always verify before making high-impact transfers.

What educators and students should emphasise

When teaching sports analytics using an FPL dashboard project, emphasise:

• Explainability: make predictions simple and interpretable for learners and peers.
• Reproducibility: track data timestamps and source URLs so others can validate your steps.
• Ethics: cite sources, respect scraping rules, and limit redistribution of copyrighted content.

Next steps & resources (2026 updates)

Recent developments to explore:

• Late-2025: more clubs published structured press feeds; check club developer pages for official APIs.
• Early-2026: community FPL APIs continue but several added stricter usage terms — always read the docs.
• AI summarisation tools are now commonly used to turn press conference audio into short injury statements; integrate these carefully and keep the original transcript.

Useful starters: the FPL bootstrap JSON endpoint (common community knowledge), club RSS feeds, and BBC Sport team-news pages for weekly roundups. For advanced students, try exporting sheet snapshots and running backtests in a Colab notebook with pandas.

Checklist before a Gameweek

• Run data refresh (Apps Script/Power Query).
• Check Dashboard injury alerts and verify any Out/Doubt players via club/BBC sources.
• Recompute xPts and update captain/transfer suggestions.
• Send yourself alerts for any high-risk changes in your squad.

Final thoughts

Building an FPL data dashboard is an excellent hands-on project for students and teachers — it combines data ingestion, cleaning, modelling, and visualisation while producing a tool you can actually use. The approach in this tutorial balances automation with human verification (especially for injury news) and reflects trends in 2026: more structured data, stronger legal protections around content and emerging AI summarisation tools.

Call to action

If you want a ready-made starter template, email or comment below with "FPL Dashboard Template" and your preferred platform (Google Sheets or Excel). Try this tutorial in a small group: compare predictions, debate captain choices and submit your best-performing model as a class assignment. Need help adapting this for a lesson plan or an assignment rubric? Ask — I’ll help you design a 2–3 week module with assessment criteria and example datasets.

Related Reading

• Best Bus Routes and Shuttles for Ski Trips With a Mega Ski Pass
• How Celebrity-Endorsed Stationery Can Elevate Your Modest Capsule Wardrobe
• Gadgets That Are Worth Buying for Seafood Lovers — and Those That Aren’t
• Discoverability 2026: How Digital PR and Social Search Must Work Together
• Italy vs. Activision Blizzard: What the AGCM Investigations Mean for Mobile Monetization