Conference website with Astro 5 and Tailwind 4: AI-first 2026

I published a “behind the scenes” article on how we are building the CMS Conf 2026 website, and it is much more than “just a landing page”.

In the article I describe:

• why we chose Astro 5 + Tailwind CSS 4 for performance and easy maintenance,
• how we use a Git-native headless CMS (Pages CMS) instead of a traditional backend,
• what we did around SEO, Schema.org and event-specific structured data,
• and how we are preparing the site for AI-assisted search, among other things through llm.txt, llm.json and automatic updates during the site build.

It is a practical story about design, frontend architecture, content work and optimizing for both search engines and language models, built by a small, focused team.

If you are interested in modern conference websites, static architectures or AI-ready SEO, you may find it useful.

#Astro #TailwindCSS #SEO #LLMO #AISEO #HeadlessCMS #StaticSites #CMSConf

#How to build a conference website with Astro 5 and Tailwind 4

Mariusz Szatkowski Developer {WordPress | WooCommerce | AI | GEO | AEO | LLMO}

December 18, 2025

When we started planning the digital presence for CMS Conf 2026, we knew the standard “WordPress theme + plugins” route would not be enough. We wanted something different. We needed a site that would not be just a brochure, but a high-performance content platform: fast, easy to maintain and explicitly designed for the AI era.

This is the story of how our website team, Agnieszka Palmowska, Maciek Palmowski and I, built the foundations for CMS Conf 2026 using a modern stack that sits right in the sweet spot of web development today.

#Website performance with Astro 5 and Tailwind CSS 4

We chose Astro 5 for one simple reason: performance is a feature.

By default, Astro ships zero JavaScript to the client. That means our pages load instantly, which is critical for mobile users checking the schedule or the speakers on weak conference wifi. We paired it with Tailwind CSS 4 (using the new Vite plugin), and that was a revelation.

We measured the implementation with several tools, one of them Google PageSpeed Insights, and here are the results:

Result 100 achieved

Let me explain what this means in practice. When we talk about “zero JavaScript”, we do not just mean smaller bundle sizes. We mean a fundamental shift in how web development is approached. Traditional SPAs (Single Page Applications) often ship hundreds of kilobytes of JavaScript just to render what could be simple static content. Astro flips that model.

Here is how it works: Astro renders the whole page to static HTML at build time. It only “hydrates” interactive components when needed, and even then it does so selectively. If you have a component that has to be interactive (like a navigation menu or a form), Astro can isolate just that component and load its JavaScript independently, leaving the rest of the page as lightweight HTML.

This approach gives us the best of both worlds: the performance of static pages with the interactivity of modern web applications when we need it.

Technical tip: If you are moving to Tailwind 4, use the @tailwindcss/vite plugin. It compiles your CSS in milliseconds, which makes the developer experience incredibly fast. We also implemented LightningCSS (written in Rust) for minification and built a custom Vite plugin for preloading critical CSS, eliminating the annoying “flash of unstyled content” (FOUC).

Let me go deeper into our Tailwind CSS 4 setup. The new version is an engine written from scratch. Scanning files for class names at build time is still there, but Tailwind 4 detects sources on its own, so the content array from version 3 is no longer needed, and configuration has moved from JavaScript to CSS through the @theme directive. This means:

1. Faster rebuilds: incremental builds that do not compile new CSS skip the most expensive step, so a class change shows up immediately
2. Smaller bundles: only the classes that actually appear in source files end up in the output

We also implemented a custom design token system using Tailwind’s CSS variable features. It lets us keep the whole site consistent while still being flexible enough to override values when needed. For CMS Conf we defined our color palette, type scale and spacing system as CSS variables, and then referenced them in our Tailwind configuration.

Our performance work did not stop there. We implemented:

• Inlined critical CSS for above-the-fold content
• Lazy loading for images and iframes
• Resource hints (preconnect, prefetch, preload) for external assets
• A service worker for offline functionality
• CDN optimization with automatic image optimization

#Pages CMS as a Git-based headless CMS

A common bottleneck in static site projects is content management. Developers love Markdown; marketing teams… not so much.

Maciek solved this by integrating Pages CMS (https://pagescms.org). It is a brilliant headless CMS that works directly with your GitHub repository. It gives our content team a friendly interface for managing blog posts and author profiles, but under the hood it is just committing changes to our repo.

Why it works:

• Zero infrastructure: There is no database to maintain and no servers to patch.
• Git-native: Every content change triggers our CI/CD pipeline, making sure nothing breaks.
• Cost: It is free for public repositories.

Let me explain how we actually put this into practice. A traditional CMS approach often involves a separate database, an authentication system and an API layer. That adds complexity, cost and potential security holes. Pages CMS takes a completely different approach.

Here is our setup: we created a dedicated content directory in our repository with clear folder structures for different content types:

content/
├── blog/
│   ├── post-1.md
│   └── post-2.md
├── speakers/
│   ├── speaker-1.md
│   └── speaker-2.md
└── schedule/
    ├── day-1.md
    └── day-2.md

Each Markdown file contains a frontmatter section with structured metadata:

---
title: "Budowanie Nowoczesnych Stron Konferencji"
author: "Mariusz Szatkowski"
date: "2025-12-18"
tags: ["astro", "tailwind", "cms"]
status: "published"
featured: true
---

Pages CMS reads these files and presents them in a friendly interface. Our content team can:

1. Create new content in a web editor with live preview
2. Edit existing content in a rich text editor that saves clean Markdown
3. Manage media by uploading images that are automatically optimized and stored in our repository
4. Review changes through a built-in process with draft/published states
5. Collaborate with comments and suggestions directly in the CMS

The beauty of this approach is that when someone makes a change in Pages CMS, it creates a pull request in our GitHub repository. That means:

• All changes go through our normal code review process
• We can run automated tests on content changes
• We have a full audit trail of every modification
• We can roll back changes when needed
• We can deploy content updates independently of code changes

We also implemented custom validation rules to ensure content quality. For example, we require every blog post to have:

• A minimum word count of 500
• At least one featured image
• Proper SEO metadata
• No broken internal links

These validations run automatically when content is saved, giving our content team immediate feedback.

The build process picks up content changes on its own. When they are merged into main, our CI/CD pipeline automatically:

1. Builds the site with the new content
2. Runs accessibility and performance tests
3. Deploys to production
4. Invalidates the CDN cache
5. Sends notifications to the relevant team members

This Git-based approach has transformed how we handle content. Our marketing team can now ship updates without developer intervention, while we keep full control over the technical implementation.

#Schema.org for the event and the organization

Ranking in 2026 takes more than keywords. You need structure.

We went deep on Schema.org implementation. We built a custom SchemaOrg.astro component that dynamically generates JSON-LD structured data for every page.

What we implemented:

• Organization schema: Identifying Openweb S.C. as the legal entity.
• Event schema: Giving Google precise dates, the location (PPNT Gdynia) and ticket information.
• @id linking: Crucially, we use @id references to “connect the dots” between the organization and the event in Google’s Knowledge Graph.

Pro tip: Do not rely on default SEO plugins to do everything. Customizing your Schema to link entities (for example, connecting your Event to your Organization by ID) is a powerful signal to search engines about who you are and what you do.

#What is an llm.txt file for AI models

This is my favorite part. Search is changing. People ask ChatGPT and Perplexity about events as often as they use Google. To make sure these AI systems give accurate answers about CMS Conf, we optimized the site for them.

We implemented an llm.txt file in the root directory of our site.

Think of it like robots.txt, but for LLMs. It provides a structured, context-rich summary of the whole conference, the speakers, the dates and the tech stack, explicitly formatted for AI ingestion. We even wrote a custom Node.js script (scripts/update-llm-txt.js) that runs at build time to scan our metadata and keep this file perfectly up to date.

The result? When an AI scans our site, it does not have to guess. We tell it exactly what CMS Conf is.

#How to check for broken links in Astro before the build

Finally, we automated the boring stuff. We set up an astro-link-validator pre-build check to make sure we never ship a bad link. We verified our redirects in astro.config.mjs so they handle legacy URLs gracefully.

#Summary

Building the CMS Conf website was not just about code; it was about creating a system that serves our users (speed), our team (manageability) and the machines that help people find us (SEO & AI).

If you are building a content-rich site in 2026, I recommend looking at this Astro + Tailwind + Git-based CMS architecture. It is lean, it is fast and it scales beautifully.

See it at: https://cmsconf.com/

We are just getting started. See you in Gdynia in November!

#WebDevelopment #AstroJS #TailwindCSS #SEO #AI #CMSConf2026 #TechStack

See our SEO and AI visibility optimization services if you want to put this area in order in your own project.

A conference website on Astro still needs AI integration with WordPress once the CMS behind the schedule starts answering assistants.