Project

Rebuilding the Face of Europe's Leading AI Student Initiative

I led the redesign of tum-ai.com, turned the TUM.ai brand guide into a tested design system and an npm UI kit, and made the next TUM.ai sites cheap to build.

16 min read11.11.2026
Screenshot of the redesigned TUM.ai homepage: the headline "Germany's leading AI student initiative." in light violet on a dark purple background, a line about 150+ students from 30+ universities, two buttons and a large A shape framing a photo of a packed auditorium.

The TUM.ai website had a number problem. The Apply page said the initiative had "over 90 active members". The homepage said the same in its intro text, while a stats row in the same file listed "400+" alumni and "33+" nationalities. The Partners page said 150 active members and 850 alumni. Nobody was lying on purpose. Each number was typed into whichever file someone happened to be editing, and none of them knew about the others.

I led the redesign of tum-ai.com, where I'm Head of Software Development. Every page was rebuilt on one design system, translated from TUM.ai's 2026 brand guide, and that design system became @tum.ai/ui-kit, an npm package. The website, the Summit and the Makeathon run on it now.

A good part of this post is about what went wrong along the way: shared components that got rebuilt instead of used, screenshot tests that lied in both directions, and a tidy architecture rule the bundler quietly punished. The other part is the design, and what it pays back later: the Makeathon and Summit sites start from the same kit instead of from scratch, and the Summit site was built by someone who had never worked on the kit.

A rule nobody can forget

The member counts were the most visible symptom, not the only one. The old site mixed stock Tailwind greys and purples into the brand colours, had unlayered global button and a styles that components fought with !important, kept animating loops for visitors who had asked for reduced motion, and built its FAQ from clickable divs. Each of these is small. Together they are what a site looks like after many people have edited it over several years, each fixing the page in front of them.

The site URL alone was written out 26 times in a single SEO file. Here is what the member figures looked like:

tsx
1// src/components/apply/About.tsx
2diverse group of over 90 active members, each with technical skills
3
4// src/components/home/AboutSection.tsx
5const STATS = [
6 { title: "Alumni Members", value: "400+" },
7 { title: "Nationalities", value: "33+" },
8 ...
9];
10With over 90 active members, TUM.ai empowers the next generation
11
12// src/data/partners.ts
13{ value: "1000+", label: "Official members", detail: "150 active, 850 alumni" },

Correcting the numbers once would have lasted until the next edit. So the figures now live in one place, the siteSettings document in Sanity, where they can be changed in the Studio without touching code. Pages and structured data read them from there. The code only defines their shape and derives the rest, like the total membership:

typescript
1// src/config/site-settings-content.ts: one CMS document holds the figures
2export const SITE_SETTINGS_QUERY = defineQuery(`*[_type == "siteSettings"][0]{
3 organization{foundingYear, activeMembers, alumni, majors, universities, nationalities, ...},
4 ...
5}`);
6
7// src/config/organization.ts: code derives from them, it never stores them
8/** Everyone who has been an official member: active members plus alumni. */
9export function officialMembersOf(
10 facts: Pick<OrganizationFacts, "activeMembers" | "alumni">,
11): number {
12 return facts.activeMembers + facts.alumni;
13}
14
15// Editable copy names a figure by placeholder, {{org.activeMembers}},
16// and the page fills it in when it renders.

The second half is what makes it stick. A guard test walks every source file and fails when it finds a fact typed straight into page code: "N active members", a role email, a social link, an application form URL. Its allowlist can only shrink, and the test says what to do when it fails: read the value from where it lives instead of silencing the pattern.

This is the first lesson, and the rest of the post keeps returning to it. A sentence in a contributing guide is a suggestion. A failing check with a message that names the right file is a rule.

Not a rewrite from zero

The site has a longer history than this redesign. The original tum-ai/website ran on Next.js with a three.js scene and content from Notion. Its successor, website_new, started as React 19 on Vite. Jakob Friedrich moved it to Next.js, Benjamin Hadizamani moved its content to Sanity, and the team that built its pages is the reason there was something to redesign at all. My own work on it started in September with an E-Lab refresh and a rebuilt partner page. The partner page set a higher bar than the rest of the site, and the redesign was the attempt to bring every other page up to it.

From a brand guide to a system

The look had a source too. TUM.ai has a 2026 brand guide: 17 slides with six colours and a gradient, the Manrope typeface in four weights, a construction grid for the logo, and section slides where a huge, faint "A" from the logomark fills the background. What it doesn't say is what a hover state looks like, which grey belongs on a dark band, or whether white text on the brand violet is readable on a button. A brand guide describes how TUM.ai looks. A website needs a lot of small decisions the slides never had to make.

So the first step was turning the guide's colours into tokens: named values the code can use. The brand colours became fixed points on a violet scale, and the shades in between were filled in from them. Then came the first real decision. White text on the brand violet, Electric Lavender, is hard to read: it reaches a contrast of about 4:1, and the accessibility standard WCAG AA asks for 4.5:1. So primary buttons use the next darker shade, #8052C2, which reaches 5.4:1. One colour isn't from the guide at all: the near-black behind the footer, #0D0214, was added in code for the darkest background.

The bigger idea is the tone band. A page is a sequence of full-width bands, and each band sets one of six tones. Components never pick a colour themselves. They ask the band for its text, muted text, hairline and accent colours, so the same card works on a white reading band and on a dark indigo hero. That's also why there is no separate dark mode: the dark bands are the dark mode. Where two light or two dark bands meet, the lower one fades in softly. Where light meets dark, the edge stays hard on purpose.

The six tone bands in @tum.ai/ui-kit. Every text and background pair meets WCAG AA.
BandCanvasTextUsed for
paperWhite#FFFFFFDark IndigoDefault reading band
mistMinimal Grey#EFEFEFDark IndigoAlternate light band
lavenderLavender Tint#F5EFFFDark IndigoSoft emphasis, forms, FAQs
inkDark Indigo#1B0049WhiteHeroes, feature bands, calls to action
nightBrand black, not in the guide#0D0214WhiteDeep contrast, footer
violetElectric Lavender#9A64D9Brand blackLarge type only, sparingly

Type and shape follow the same pattern: take what the guide shows and turn it into a rule. The guide sets its H1 at 120 points, and the kit's brand doc asks for "large, light-weight headlines", so the largest display size scales up to 8rem at weight 300 with tight letter spacing. The guide sets labels like "Primary Logo" in mixed case, never in capitals, so the kit's eyebrow labels never shout in all caps either. Even the guide's signature corner, one large radius and three small ones, is a utility class now.

The homepage hero takes the big faint A from the section slides and turns it into a window: event photos crossfade slowly inside the logomark, which is about as literal as the guide's "Our photos put you in the room" gets. The hero's construction lines need exact geometry, so its construction sheet draws its own mirror-symmetric A, with the feet where the official mark has them, and a test checks that every guide circle is tangent to the stroke it belongs to. The header keeps the supplied logo file.

Motion follows the guide's character as the kit's brand doc sums it up: precise, confident, calm and alive, where alive means "small, purposeful motion that is always optional". In code that is a house easing curve, five named durations, and ambient loops that don't run at all for visitors who asked for reduced motion.

Then comes the part that connects back to the member counts. In the kit, checks enforce the brand rules. A lint rule rejects raw hex values and stock Tailwind palettes, another rejects animations that skip the motion tokens, and a test fails if any tone's text, accent or focus colour drops below WCAG AA. The website itself still relies on written rules and design review for this, so the strict version of the rule lives in the kit, which is where most of the styling lives now anyway. One rule can't be linted, and the kit's brand doc states it plainly: "If a design starts to look like a generic SaaS template, simplify it."

What changed on screen

Here's what that system looks like on the pages. Every page now sits on it, and accordions, dialogs and the mobile menu are built on Base UI, so keyboard and screen reader behaviour come from a library instead of hand-written handlers. Drag the divider to compare.

The redesigned TUM.ai homepage at desktop width: a large light-violet headline "Germany's leading AI student initiative.", a short line with member figures, two pill buttons, a large A shape framing an auditorium photo, and a row of partner logos.The previous tum-ai.com homepage at desktop width: a dark hero with a dimmed photo grid, the TUM.ai logo, the line "Germany's leading student initiative focused on Artificial Intelligence" and two buttons.
The homepage, the old site on the left of the divider and the new one on the right.
The redesigned TUM.ai homepage on a phone: the new headline in three lines, the member figures and two stacked pill buttons.The previous tum-ai.com homepage on a phone: a large TUM.ai logo, the tagline and two stacked buttons on a dark background.
The same at 390 px. The member figures in the intro now come from the CMS settings shown above.

The homepage is only one page. Here are four more, old on the left of the divider and new on the right.

The redesigned Research page: a large light-violet heading, a line about publishing at NeurIPS, ICML and ICLR, two buttons and a dotted globe marking Munich.The previous Research page: a plain heading, two filter tabs and a row of project cards with mixed illustration styles.
Research: a row of mismatched cards becomes one statement and a map of where the work happens.
The redesigned E-Lab page: the E-Lab wordmark, the headline "12 weeks from kickoff to the Final Pitch.", a short description and a dotted map.The previous E-Lab page: a large E-LAB 6.0 wordmark on a purple gradient with a closed applications badge.
E-Lab: the logo splash makes room for what the program actually is.
The redesigned Community page: the headline "The people who run TUM.ai.", member figures, two buttons and a group photo.The previous Community page: a "Member Journey" diagram of boxes connected by curved lines.
Community: the process diagram is replaced by the people and the numbers behind them.
The redesigned Apply page: the headline "Call for members.", the winter semester application window and a timeline of deadlines, interviews and the onboarding weekend.The previous Apply page: a "Join Us" heading, a paragraph and a large TUM.ai logo.
Apply: instead of a logo, the page leads with the dates an applicant actually needs.
Loading image...
The new Hackathons page: the headline "We run the Makeathon. We founded the EHL.", buttons for both events, the next event date and a bar timeline of past hackathons since 2021.
Hackathons: a page the old site did not have.

Structure the bundler agrees with

Before, one page's code was spread across five top-level folders. The E-Lab page had a route in src/app, its view in src/views, sections in src/components/e-lab, content in src/data/e-lab and helpers in src/lib. Now each domain is a feature folder, and routes stay thin:

text
1// before: main
2src/
3├── app/e-lab/page.tsx
4├── views/headerPages/e-lab/ELab.tsx
5├── components/e-lab/TimeLine.tsx, Testimonials.tsx, ...
6├── data/e-lab/FAQ.tsx, e-lab.tsx, ...
7└── lib/
text
1// after: the redesign and cleanup branch
2src/
3├── app/(site)/e-lab/page.tsx // imports exactly one page module
4├── features/e-lab/
5│ ├── e-lab-page.tsx
6│ ├── hero.tsx, venture-trace.tsx, ... (+ tests beside them)
7│ ├── data/faq.ts
8│ └── server.ts // CMS content getters, server-only
9├── components/shell/ // header, footer
10├── config/ // site facts: organization.ts, e-lab.ts, ...
11└── lib/

Layering is easy to draw and easy to ignore, so it's a test. src/architecture.test.ts reads every import from the TypeScript syntax tree and checks it against a table: a route may import its feature's page module, a feature may import the shell, config and lib, config may only import config and lib. There are no exceptions. An import that breaks a rule either changes the code or deliberately changes the rule.

The first version of that table had a rule that looked cleaner: every feature exposes its pages through an index.ts barrel. It didn't survive measurement. Turbopack keeps every re-exported module that has client islands or a CSS import, so the homepage shipped the partners page's interactive pieces in a 54 KB chunk, and the legal pages carried 17.7 KB they never used. The rule became "a route imports exactly its page module", and the restructure ended up with 18.6 KB less JavaScript per page.

Screenshots are a test you have to engineer

Every route has screenshot baselines at 390 and 1440 px in Chromium and WebKit. I expected that part to be the easy one. It wasn't.

  • They were too heavy. The first baselines weighed 90 MB, up to 5.4 MB for a single full-page shot, and WebKit decoded the same photos differently between runs. Photos and film grain are now hidden during capture, which made the comparison stable and cut the set to 44 MB.
  • The threshold lied. A ratio of 0.1% sounds strict, but on a long page it allows thousands of changed pixels. Switching to a fixed 100 pixels per screenshot immediately exposed nine baselines that had drifted unnoticed.
  • They went stale anyway. When the website moved to the kit, all 48 checked-in screenshots from the older branch no longer matched the current rendering, and the capture bot had snapped some animations mid-state, a half-drawn timeline and a globe before its dots appeared. Those had to be fixed by hand.

Baselines are now captured only in CI, triggered by a label, never on someone's laptop. Visual regression is a real test, but it's a test you have to design like any other.

One more counterintuitive result: more CI shards made the pipeline slower. Each shard spends about a minute and a half on setup and its own build, so splitting further took a run from 3:56 to over 4:15. Parallelism has a fixed cost.

Pulling the kit out

The long-term goal had always been one design system for every TUM.ai site, not just the website. So once the website had one, I extracted it into @tum.ai/ui-kit, an MIT-licensed package built on Base UI with releases through changesets. Every site now gets the same buttons, tone bands and header without copying them.

I didn't want to extract it on trust. Twelve representative components had to produce identical screenshots at 320, 390, 768 and 1440 px inside and outside the website, a packed copy of the package had to work in a fresh Next.js app, and every Storybook story runs with strict axe checks. The verification document is also honest about what it doesn't prove: not every possible composition, and no VoiceOver or real-iPhone pass.

The FAQ shows what moving into the kit bought. This is the old one: a div with an onClick, no button semantics, no aria-expanded, nothing a keyboard can reach:

tsx
1{faq.map((faqItem, index) => (
2 <div key={index}>
3 <div onClick={() => setOpenFaqIndex(openFaqIndex === index ? null : index)}>
4 <p>{faqItem.question}</p>
5 <svg>{/* chevron */}</svg>
6 </div>
7 {openFaqIndex === index && <p>{faqItem.answer}</p>}
8 </div>
9))}

The kit version wraps a Base UI accordion. Keyboard handling, ARIA state and focus come from the library, and the kit adds deep links, so a URL fragment opens the matching question:

tsx
1<Accordion value={open} onValueChange={(next) => change(next as string[])}>
2 {items.map((item) => (
3 <AccordionItem key={item.question} value={item.question} id={item.id}>
4 <AccordionTrigger headingAs={headingAs}>{item.question}</AccordionTrigger>
5 <AccordionPanel>{item.answer}</AccordionPanel>
6 </AccordionItem>
7 ))}
8</Accordion>

Who owns what is written down in an ADR. The kit owns component behaviour, styling, tokens and their tests. The website owns routes, content and data. Kit code is never copied or patched inside a site: a fix goes upstream, gets released and arrives through a version bump. Moving the website onto the package was mostly deletion, and the before and after screenshots came out with identical dimensions. It wasn't a perfect fit either: one small class-merging helper stayed local because the kit didn't export it yet.

A Tailwind-based kit has one hidden cost. If a consumer's bundler stops picking up the kit's source, its components render unstyled while the site's own classes still work, and nothing fails. The Makeathon build now ends with a check that looks for a few kit-only selectors in the output CSS.

Every new site starts ahead

The real test of a shared kit is whether the next site gets built with it. The old Makeathon site had its own, older design. Its successor, now live at makeathon.tum-ai.com, is built on the kit. Here is the old site next to the new one:

The new Makeathon site: a huge "Makeathon" wordmark with a glowing sun rising behind it over a purple halftone dot field, the line "AI for everyone." and two buttons, under the shared TUM.ai header.The old Makeathon site: a dark navy hero with the heading "The TUM.ai Makeathon", three checklist items about launching a project, networking and prizes, and a slanted white edge.
The Makeathon site: the old design on the left, the live one built on the kit on the right.

The new Makeathon site was scaffolded on a packed copy of the kit and switched to the published npm package once it was out. Almost none of its code is UI basics. There is no button, accordion, header or footer in it. Those come from the kit. What's left is what makes the Makeathon the Makeathon: a sun that moves with the real sky over the campus, a replay of the weekend hour by hour, the results and the history of every edition.

Loading image...
The Makeathon results section: the heading "Four challenges. Five places each." above four columns, one per challenge partner, each listing five ranked teams, and a row of tech partner logos.
The results section is Makeathon-specific content laid out with the kit's type scale, tone band and header.
Loading image...
The Makeathon closing section: a sun rising over a halftone dot field above the heading "The sun rises again in 2027." and two buttons.
The halftone field and sun started here and now live in the kit, so the website's hackathons page uses the same ones.

That's what uniform means in practice. The new Makeathon site looks like TUM.ai not because someone checked it against a style guide, but because it imports the same components. A written rule in the repository keeps it that way: before building a new component, ask whether another TUM.ai site could use it, and if so, stop and propose it for the kit.

Then a component travelled the other way. The halftone dot field and the sun started in the Makeathon site, and the website's hackathons page wanted them too. Instead of a second copy, both moved into the kit as an opt-in subpath, 4.1 kB with brotli including the lazily loaded WebGL renderer, and the Makeathon deleted its own copy. That's the loop a kit exists for: a component proves itself in one site, moves up, and the original copy disappears.

The third site is the harder test, because I didn't build it. Timur Hegwein built the site for the TUM.ai Summit in San Francisco without having worked on the kit before. Wiring it in took an npm install, three CSS imports and the usual Tailwind setup. From there the page is mostly composition: header, footer, sections, stat grid, cards and the call-to-action band all come from the kit, 18 components plus the site shell by now. His own code in the first version is mostly the hero and the event content, the part that is actually about the Summit.

Loading image...
The TUM.ai Summit site at desktop width: the headline "TUM.ai Summit" in light violet on a near-black background, the line "Overengineered. Overregulated. Still world class.", a short paragraph, a "Become a partner" button, a large A shape framing a night photo of the Golden Gate Bridge, and a row of partner logos.
The Summit site. Header, type scale, tone band and button come from the kit. The photo inside the logomark is the one piece Summit rebuilt from the website by hand.

It still wasn't completely free of friction. The site works around the kit in three small places: it hides a scrollbar in the kit's header navigation, builds its own partner row because the kit's logo wall assumes a light band, and forces the stat grid into one column on phones. Its hand-built hero is the halftone story waiting to happen again: the next obvious candidate to move up into the kit.

What the kit keeps saving

The quieter win comes after launch. When the kit shipped two fixes for how iPhone Safari colours its toolbars behind the open menu and behind dialogs, the website got each one as a version bump, one line in package.json plus the lockfile. The Summit site started on the fixed version and never had the bug. Nobody on that project had to learn how Safari tints its toolbars.

The same goes for everything that's tedious to get right. Timur never had to write a contrast check, keyboard handling for a menu or a reduced-motion fallback, so a new TUM.ai site starts with that work already done instead of owing it.

Design gets the same shortcut. For each stable release, the kit generates its Figma library from code, so CSS and TypeScript stay the source of truth and Figma mirrors them once someone runs the updater plugin. Whoever designs the next TUM.ai site starts from the components that actually ship, not from a library that quietly drifted away from the code.

Sites pin an exact kit version, so an upgrade is always a deliberate one-line bump. The kit keeps saving time as long as someone bumps those versions and carries what a site learns back into it. That's real work, just far less of it than building each site from scratch.

What I'd tell the next person

  • Write the rule as a failing test. Guidelines get ignored. Nobody can merge past a red check that says which file to fix.
  • Budget time for the screenshots themselves. Visual baselines are the best refactoring safety net I know, once you've made them stable, sized and honest.
  • Measure the architecture. A clean import rule cost real kilobytes until the bundle numbers said so.
  • Turn the brand guide into rules, not just tokens. A palette in a PDF drifts. A lint rule against raw colours and a contrast test for every tone don't.
  • Shape a kit with a second consumer, and judge it by the third. The Makeathon site is why the kit has a clear API. Without a second user, it would have been the website's components with a package.json. The Summit site, built by someone who had never worked on the kit, shows that the API also makes sense from the outside.

The part I'm proudest of is the boring part. The next person who hardcodes a member count, imports across layers, shifts a layout by accident or slips an off-brand colour into the kit gets a failing check that tells them what to fix. And the next person who needs a TUM.ai site starts where the Summit started, not where the website did. That's what a redesign that stays rebuilt means to me.