Astro

Deploy your Astro applications with zero configuration and blazing-fast performance. Our platform is specifically optimized for Astro’s unique architecture, delivering the fastest possible page loads and optimal user experiences for content-focused sites.

Why Sherpa is Perfect for Astro

Zero Edge Request Charges

Unlike other platforms that charge per edge request, we never bill for edge traffic. This is especially important for Astro sites because of the framework’s islands architecture:

Astro creates highly optimized, minimal bundles

// page.html (12kb) - Pre-rendered HTML content
// island-header.js (3kb) - Interactive header component
// island-cart.js (5kb) - Shopping cart island
// island-search.js (2kb) - Search functionality

Why This Saves You Money:

• Astro’s islands architecture creates multiple small JavaScript bundles for interactive components
• Each island loads independently, generating separate edge requests
• Static assets (images, fonts, CSS) create additional edge requests
• Other platforms charge $0.01-0.10 per 10,000 edge requests
• With sherpa.software: $0.00 for unlimited edge requests

Real-World Impact:

Astro Content Site Monthly Traffic Overview

Static Pages: Approximately 3 million requests for pre-rendered HTML
Island Components: Approximately 1.5 million requests for interactive JS
Images & Assets: Approximately 4 million requests
API Calls: Approximately 500,000 requests

Cost Comparison
Other Platforms: $200-400/month in edge fees
Sherpa.sh: $0

Optimized for Static-First Performance

We’ve fine-tuned our infrastructure specifically for Astro’s static-first approach with optional SSR:

Performance Optimizations

• Instant Page Loads: Static HTML served from edge locations worldwide
• Island Hydration: Lightning-fast partial hydration of interactive components
• Asset Optimization: Automatic compression and caching for all static assets
• Build Caching: Intelligent build caching reduces deployment times by 40-60%

Performance Benchmarks:

# Time to First Byte (TTFB) - 95th percentile

sherpa.software: 42ms average globally
Traditional VPS: 280ms average
Other static hosts: 95ms average

Ready to deploy? Create a free account →

Quick Start Guide

Get your Astro site live in under 2 minutes with our streamlined deployment process.

Prerequisites

• Astro 5.x project
• Git repository (GitHub, GitLab, or Bitbucket)
• Node.js 18+ locally for development

Deployment Steps

1. Connect Repository: Link your Git repository to sherpa.software
2. Auto-Detection: We automatically detect your Astro configuration
3. Deploy: Push to your main branch triggers automatic deployment
4. Live: Your site is available at https://your-site.sherpa.software

What You Get Instantly

• Zero Configuration: Works with your existing astro.config.mjs
• Global CDN: All assets served from 200+ edge locations
• Automatic HTTPS: SSL certificates provisioned and renewed automatically
• Image Optimization: Built-in support for Astro’s Image component
• Content Collections: Full support for type-safe content management
• Pay-per-Use: No idle costs - only pay for actual usage

Note

By default CDN caching is on: Static pages are cached at the edge for maximum performance. For SSR routes, set cache-control headers on pages that need dynamic content. Please see our CDN Docs for more info on cache-control headers.

Configuration

Static Site Configuration

For static builds, ensure you are not using any adapters in your astro.config.mjs file:

astro.config.mjs

import { defineConfig } from 'astro/config';

export default defineConfig({
  output: 'static', // Default static output
  // Do not include any adapter
});

Server-Side Rendering Configuration

For server-side rendering, you must use the @astrojs/node adapter in standalone mode:

# Install the Node adapter
npm install @astrojs/node

astro.config.mjs

import { defineConfig } from 'astro/config';
import node from '@astrojs/node';

export default defineConfig({
  output: 'server', // or 'hybrid' for mixed static/SSR
  adapter: node({
    mode: 'standalone'
  })
});

Note

For SSR/Hybrid mode: The @astrojs/node adapter in standalone mode is required. Other adapters are not currently supported.

Astro Islands Architecture Benefits

Minimal JavaScript Delivery

Astro’s islands architecture works perfectly with our infrastructure:

---
// Islands load only when needed
import Header from '../components/Header.astro';
import InteractiveCart from '../components/Cart.jsx'; // React island
import SearchBar from '../components/Search.vue'; // Vue island
---

<Header /> <!-- Pure HTML, zero JavaScript -->
<InteractiveCart client:load /> <!-- Hydrates immediately -->
<SearchBar client:visible /> <!-- Hydrates when visible -->

Benefits on sherpa.software:

• Zero Hydration Cost: Static components require no JavaScript
• Selective Hydration: Islands hydrate only when needed
• Framework Agnostic: Mix React, Vue, Svelte, Solid in one project
• Edge Caching: HTML cached globally, islands cached per component

Advanced Features

Content Collections

Astro’s Content Collections work seamlessly with sherpa.software:

src/content/config.ts

import { defineCollection, z } from 'astro:content';

const blog = defineCollection({
  type: 'content',
  schema: z.object({
    title: z.string(),
    pubDate: z.date(),
    author: z.string()
  })
});

export const collections = { blog };

Platform Benefits:

• Type-Safe Content: Full TypeScript support during builds
• Fast Builds: Content collection parsing optimized for speed
• Git-Based Workflow: Content updates trigger automatic rebuilds
• Global Distribution: All content served from edge locations

Image Optimization

Astro’s Image component is fully optimized on sherpa.software:

---
import { Image } from 'astro:assets';
import heroImage from '../assets/hero.jpg';
---

<Image src={heroImage} alt="Hero" width={800} height={600} />
<!-- Automatically optimized, resized, and cached globally -->

Optimization Features:

• WebP/AVIF conversion for modern browsers
• Responsive image generation
• Lazy loading support
• Global CDN delivery
• Build-time optimization

Hybrid and Server Rendering

Full support for Astro’s SSR and hybrid modes using the Node adapter:

astro.config.mjs

import { defineConfig } from 'astro/config';
import node from '@astrojs/node';

export default defineConfig({
  output: 'hybrid', // Static by default, opt-in to SSR per page
  adapter: node({ mode: 'standalone' })
});

SSR Performance:

• Fast Cold Starts: Pre-warmed Node.js instances
• Auto-Scaling: Scales based on traffic patterns
• Edge Caching: Intelligent caching for SSR responses

Caching Strategy

Intelligent Cache Headers

We optimize caching based on your content type:

Cache-Control: public, max-age=31536000, immutable # Static assets (JS, CSS, images)
Cache-Control: public, max-age=3600 # Static HTML pages
Cache-Control: public, s-maxage=60, stale-while-revalidate # SSR pages

Cache Debugging

Check cache performance in browser DevTools:

# Response headers show cache status
Cdn-Cache: HIT    # Served from edge cache
Cdn-Cache: MISS   # Fetched from origin

Developer Experience

Local Development Compatibility

Your local development workflow remains unchanged:

# Development (unchanged)
npm run dev

# Build locally (unchanged)
npm run build

# Preview locally (unchanged)
npm run preview

# Deploy to sherpa.software
git push origin main  # Triggers automatic deployment

Build Process Insights

Monitor your builds in real-time:

• Build Time: Typical Astro builds complete in 20-45 seconds
• Content Processing: See content collection parsing time
• Asset Optimization: Track image and asset processing
• Bundle Analysis: View JavaScript bundle sizes per island

Debugging & Monitoring

Real-Time Logs

View live application logs from inside the portal. You get logging for:

• CDN requests
• Build output
• SSR requests (if using hybrid/server mode)
• Error tracking

Configuration Examples

Multi-Framework Islands

Leverage Astro’s ability to mix frameworks:

---
import ReactCounter from './Counter.jsx';
import VueCalendar from './Calendar.vue';
import SvelteChart from './Chart.svelte';
---

<div class="dashboard">
  <ReactCounter client:load />
  <VueCalendar client:visible />
  <SvelteChart client:idle />
</div>

All frameworks work seamlessly on sherpa.software with zero additional configuration.

View Transitions

Astro’s View Transitions API works perfectly:

---
import { ViewTransitions } from 'astro:transitions';
---

<html>
  <head>
    <ViewTransitions />
  </head>
  <!-- Smooth page transitions without JavaScript frameworks -->
</html>

Custom Integrations

All Astro integrations are supported:

astro.config.mjs

import { defineConfig } from 'astro/config';
import mdx from '@astrojs/mdx';
import sitemap from '@astrojs/sitemap';
import partytown from '@astrojs/partytown';

export default defineConfig({
  integrations: [mdx(), sitemap(), partytown()]
});

Enterprise Features

Advanced Security

• SOC 2 Compliance: Enterprise-grade security controls
• Custom WAF Rules: Protect against application-specific threats
• DDoS Protection: Automatic traffic filtering and rate limiting

Performance & Reliability

• 100% Uptime SLA: Guaranteed uptime with financial backing
• Custom Edge Logic: Run code at 200+ global locations
• Dedicated Infrastructure: Isolated compute for enterprise workloads

Developer Support

• Dedicated Account Manager: Direct line to platform experts
• Priority Support: <2 hour response time for critical issues
• Custom Integrations: Connect with your existing DevOps tools

Troubleshooting

Getting Help

• Documentation: Comprehensive guides here
• Community Support & Tickets: Join our Discord

Migration Guide

From Other Platforms

The easiest way to migrate from another platform is to follow the quickstart guide.

• Create a free account →
• Connect Github
• Configure your application settings

From Static Hosts

Key differences when migrating from traditional static hosts:

• SSR Support: Optionally enable hybrid or server mode with @astrojs/node adapter
• Build Caching: Faster rebuilds with intelligent caching
• Island Optimization: Better performance for interactive components
• Unified Platform: No need for separate services for SSR
• Adapter Requirement: Use standalone mode for the Node adapter if using SSR/hybrid

Next Steps

After deploying your first Astro site:

1. Custom Domain: Connect your domain in the dashboard
2. Environment Variables: Configure secrets and API keys
3. Content Collections: Set up your content structure
4. Team Access: Invite collaborators with role-based permissions
5. Monitoring: Set up alerts for performance and errors

Ready to deploy? Create a free account →