Astro Launch Checklist: 25 Essential Steps

Execute `astro check` to validate all `.astro` files for type errors, missing props, and template issues. This catches problems that the dev server silently ignores but that will break in production builds or confuse future developers.

Set `output: 'static'` for fully pre-rendered sites, `output: 'server'` for SSR, or `output: 'hybrid'` for a mix. The wrong mode causes either missing dynamic functionality or unnecessary server infrastructure costs.

Add the adapter matching your host — `@astrojs/vercel`, `@astrojs/netlify`, `@astrojs/cloudflare`, or `@astrojs/node`. Without the right adapter, SSR routes and server endpoints will fail silently in production even if they work in dev.

Use Astro's `env.schema` in `astro.config.mjs` to declare and validate every environment variable. This provides type safety and fails the build immediately when a required variable is missing, rather than failing at runtime in production.

The dev server behaves differently from production — it skips optimizations, handles errors more leniently, and does not apply production routing rules. Always preview the actual build output before deploying to catch issues the dev server hides.

Use `defineCollection` with Zod schemas that validate required fields, enforce string lengths, and constrain enum values. Loose schemas let malformed content slip through, causing broken pages or missing data that you only discover when a user reports it.

Run `astro check` or build to verify every Markdown/MDX/JSON file passes its Zod schema. A single missing frontmatter field in one of 200 blog posts will crash the build or produce a broken page — catch it before deploy.

In `[slug].astro` pages, use `getStaticPaths` to return a path for every collection entry. Missing entries produce 404s that are hard to detect because the build succeeds — verify the count of generated pages matches your content count.

Use Astro's built-in `paginate()` function in `getStaticPaths` to split large collections into pages of 10-20 items. Unbounded pages with hundreds of entries slow down rendering, consume excessive memory, and create poor user experiences.

Include a `draft: z.boolean().default(false)` field in your content schemas and filter it in `getStaticPaths` and collection queries. Without draft filtering, content authors can accidentally publish work-in-progress pages by committing them to the content directory.

Review every component using `client:load`, `client:idle`, or `client:visible`. Many components marked for hydration only need static HTML — a nav menu that never opens via JavaScript, or a card grid with no interactivity. Each hydrated island ships its framework runtime.

Components like comment sections, interactive charts, or newsletter forms that are not visible on initial load should use `client:visible` instead of `client:load`. This defers JavaScript loading until the user scrolls to the component, improving initial page load time.

Test every interactive island in the preview build — not just dev mode. Hydration mismatches between server-rendered HTML and client JavaScript cause flickering, broken event handlers, and console errors that only appear in production.

If you use React, Vue, and Svelte islands on the same page, the browser downloads three framework runtimes. Consolidate to one or two frameworks maximum, or use Astro's own `<script>` tags for simple interactivity that does not require a framework at all.

Components that hydrate lazily show static HTML until JavaScript loads. If the static version looks broken or empty, add a CSS-only loading skeleton or placeholder that displays until hydration completes, preventing layout shift and user confusion.

Replace `<img>` tags with Astro's `<Image />` component from `astro:assets`. It automatically generates optimized formats (WebP/AVIF), responsive sizes, and correct `width`/`height` attributes to prevent CLS. Raw `<img>` tags skip all of these optimizations.

The hero image and any images visible without scrolling should load eagerly for fast LCP. All other images should lazy-load to save bandwidth. Astro's `<Image />` defaults to lazy loading, so you only need to override the above-the-fold ones.

Set `prefetch: true` in your Astro config or add the `prefetch` attribute to individual links. Astro will prefetch linked pages on hover or when they enter the viewport, making navigation feel instant for users.

Astro automatically inlines CSS for static pages, but verify this works for your setup by checking that the initial HTML contains styles for above-the-fold content. Third-party CSS files loaded via `<link>` should use `media='print' onload` pattern or be moved to component-scoped styles.

Test the actual built output (not dev server) with Lighthouse in Chrome DevTools on both mobile and desktop. Astro sites should score 95+ easily — if you are below that, you likely have an unoptimized island, a large uncompressed image, or a render-blocking third-party script.

Use Astro's `<head>` section or a shared `BaseHead.astro` component to inject per-page metadata. Duplicate titles across pages confuse search engines about which page to rank, and missing OG tags produce ugly social media previews when users share your links.

Install `@astrojs/sitemap` and set the `site` property in `astro.config.mjs`. The integration automatically generates a sitemap.xml from all your routes. Submit it to Google Search Console within the first hour of launch to accelerate indexing.

Create a `public/robots.txt` or use a dynamic endpoint that allows all user agents on public routes and disallows admin, API, and draft pages. A missing robots.txt is fine, but an incorrect one can block search engines from indexing your entire site.

Create `src/pages/404.astro` for static mode or add error handling middleware for SSR mode. Default error pages look unprofessional and provide no navigation — custom error pages keep users on your site and guide them to working content.

Configure 301 redirects in your `astro.config.mjs` `redirects` field or in your hosting provider's config for any URLs that were shared, bookmarked, or indexed during development. Broken links from external sites permanently lose you referral traffic and backlink value.