explaingit

guardian/frontend

★ 5,888ScalaAudience · developerComplexity · 4/5Setup · hard

TLDR

The Scala backend that powers theguardian.com, it fetches content and builds data passed to a rendering layer, enforcing strict rules like sub-500ms responses and a single external API call per request.

Mindmap

mindmap
  root((guardian/frontend))
    What it does
      Content aggregation
      Data for renderer
      Caching layer
    Tech stack
      Scala
      Play Framework
      SBT and Make
    Performance rules
      Under 500ms
      One external call
      2s hard cutoff
    Setup
      SBT for server
      Make for assets
      Docs folder
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Things people build with this

USE CASE 1

Study a real-world high-traffic Scala web application enforcing strict caching and performance contracts.

USE CASE 2

Learn how a major news site structures a Play Framework backend that feeds a separate rendering system.

USE CASE 3

Reference a production SBT project layout when building your own content-driven web service.

Tech stack

ScalaPlay FrameworkSBTMakeJavaScriptCSS

Getting it running

Difficulty · hard Time to first run · 1h+

Requires the Scala toolchain via SBT plus Node.js for client-side assets, setup docs live in a separate docs folder.

In plain English

This is the backend codebase that powers the frontend of The Guardian's website, theguardian.com. Despite the name, its job is not to render pages directly for readers. Instead, it collects content and builds data that gets passed to a separate rendering system called Dotcom Rendering, which produces the actual pages visitors see. The application is built with Play Framework, a web framework for Scala. The build process has two parts: client-side assets (CSS, JavaScript, images) are compiled using Make, while the server-side application is built with SBT, the standard build tool for Scala projects. The codebase operates under a set of strict performance rules. Every request must be cacheable with a proper cache header. Each request is allowed only one call to an external service, such as The Guardian's content API. Responses are expected to come back in under 500 milliseconds on average, and any request taking more than two seconds is cut off automatically. Documentation lives inside a dedicated docs folder in the repository. New developers are directed there for installation steps, a troubleshooting guide, development tips, and instructions on how to deploy changes. The README is intentionally brief and points readers to those docs rather than repeating their contents inline. This is a production codebase from a major news organization, and the emphasis throughout is on speed and reliability at scale.

Copy-paste prompts

Prompt 1
I am learning Play Framework with Scala. Using The Guardian frontend repo as a reference, show me how to structure a controller that fetches from an external content API and returns a cached response.
Prompt 2
How does The Guardian frontend enforce the rule that every request must complete in under 500 milliseconds? Show me the timeout configuration in Play Framework.
Prompt 3
Walk me through the SBT project structure in The Guardian frontend repo and explain what each module does.
Prompt 4
I want to set up local development for The Guardian frontend. What are the steps from cloning the repo to running the app locally?
Open on GitHub → Explain another repo

← guardian on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.