Sveltekit

Deploy your SvelteKit applications with zero configuration and enterprise-grade performance. Our platform is specifically optimized for SvelteKit's architecture, delivering faster builds and better runtime performance than traditional hosting solutions.

Why sherpa.sh is Perfect for SvelteKit

Zero Edge Request Charges

Unlike other platforms that charge per edge request, we never bill for edge traffic. This matters for SvelteKit because of its intelligent code-splitting strategy:

SvelteKit automatically creates many small chunks

// app.js (5kb) - Core application logic
// chunk-abc123.js (2kb) - Home page component
// chunk-def456.js (3kb) - About page component
// chunk-ghi789.js (1kb) - Shared utilities

Why This Saves You Money:

SvelteKit creates 20-50+ small JavaScript chunks per application (or more!)
Each chunk loads on-demand, triggering separate edge requests
Other platforms charge $0.01-0.10 per 10,000 edge requests
With sherpa.sh: $0.00 for unlimited edge requests

Real-World Impact:

SvelteKit App Monthly Traffic Overview

Static Assets: Approximately 2 million requests for JS chunks, CSS, and images
SSR Pages: Approximately 500,000 requests
API Calls: Approximately 1 million requests

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

Optimized Node.js Adapter Performance

We've fine-tuned our infrastructure specifically for @sveltejs/adapter-node to deliver optimal SSR performance:

SSR Performance Optimizations

Cold Start Elimination: Pre-warmed Node.js instances across regions
Memory Optimization: 512MB-2GB+ containers with intelligent horizontal scaling
Request Routing: Smart load balancing based on geographic proximity

Performance Benchmarks:

# SSR response times (95th percentile)

sherpa.sh: 89ms average globally
Traditional VPS: 340ms average
Other serverless: 180ms average (with cold starts)

Ready to deploy? Create a free account →

Quick Start Guide

Get your SvelteKit app live in under 2 minutes with our streamlined deployment process.

Prerequisites

SvelteKit 2.x project
Git repository (GitHub, GitLab, or Bitbucket)
Node.js 18+ locally for development

Deployment Steps

Connect Repository: Link your Git repository to sherpa.sh
Auto-Detection: We automatically detect your SvelteKit configuration
Deploy: Push to your main branch triggers automatic deployment
Live: Your app is available at https://your-app.sherpa.sh

What You Get Instantly

Zero Configuration: Works with your existing svelte.config.js
Global CDN: Static assets served from 200+ edge locations
Automatic HTTPS: SSL certificates provisioned and renewed automatically
Performance Optimization: Built-in code splitting and asset preloading
Pay-per-Use: No idle costs - only pay for actual usage

Platform Optimizations

Automatic Configuration Overrides

When you deploy to sherpa.sh, we automatically optimize your configuration for maximum performance:

svelte.config.js Modifications

// Your original config is preserved, but we enhance it:
export default {
  kit: {
    adapter: adapter({
      out: 'build',
      trustProxy: true // Handles load balancer headers
    }),
    paths: {
      assets: 'https://your-app.sherpa.software/{versioning-hash}' // Global CDN w/ hash for easy rollbacks
    }
    // Your other settings remain unchanged

Environment Variables Set Automatically

PORT=3000                                  # Standard runtime port
ORIGIN=https://your-domain.com             # Your custom domain
NODE_ENV=production                        # Production optimizations
PROTOCOL_HEADER=x-forwarded-proto          # HTTPS detection
HOST_HEADER=x-forwarded-host               # Proper host handling

Performance Enhancements

Code Splitting Optimization

SvelteKit's automatic code splitting works perfectly with our HTTP/2 infrastructure:

Parallel Chunk Loading in Routes

Your route-based chunks load in parallel, requiring no additional configuration—this functionality works automatically.

Static Asset Acceleration

File Hashing: Long-term caching for unchanged files
Compression: Automatic Brotli and Gzip compression
Edge Caching: Assets cached globally for <50ms load times

Prerendering Support

To enable prerendering in your routes, use the following snippet:

// In routes that can be prerendered:
export const prerender = true;
// These routes are built as static HTML and

Advanced Features

Image Optimization

Automatic image optimization with SvelteKit's enhanced:img component:

svelte<!-- Original image --><img src="/hero.jpg" alt="Hero image" /><!-- Automatically optimized, cached, and served from CDN -->

Optimization Features:

WebP/AVIF conversion for modern browsers
Responsive sizing based on device
Lazy loading below the fold
Global CDN delivery

Caching Strategy

Intelligent Cache Headers

We will use whatever cache-headers you set in Sveltekit setup, otherwise default to these.

Cache-Control: public, max-age=31536000, immutable # Static assets (JS, CSS, images)
Cache-Control: public, max-age=3600 # Prerendered pages
Cache-Control: no-cache # API routes

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

Load Balancing & Scaling

Server-Side Rendering (SSR)

Auto-scaling Node.js instances
Geographic distribution for reduced latency
Zero-downtime deployments

Developer Experience

Local Development Compatibility

Your local development workflow remains unchanged:

# Development (unchanged)
npm run dev

# Build locally (unchanged)
npm run build

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

Build Process Insights

Monitor your builds in real-time:

Build Time: Typical SvelteKit builds complete in 30-60 seconds
Bundle Analysis: See which routes contribute to bundle size

Debugging & Monitoring

Real-Time Logs

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

CDN requests
Live Node Console

Configuration Examples

Custom Headers

Here's a reformatted version of the Svelte configuration snippet with improved readability and structure:

// In your svelte.config.js
export default {
  kit: {
    adapter: adapter(),
    // Add custom headers for specific routes
    headers: {
      '/**': {
        'X-Frame-Options': 'DENY',
        'X-Content-Type-Options': 'nosniff'
      }
    }

Environment-Specific Configuration

// Different configs per environment
const config = {
  kit: {
    adapter: adapter(),
    paths: {
      base: process.env.NODE_ENV === 'production' ? '/app' : ''
    }
  }
};

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 migration from another platform is to follow the quickstart guide.

From Self-Hosted

Key differences when migrating from self-hosted SvelteKit:

Remove PM2 or Docker configurations
Environment variables managed in dashboard
No need for reverse proxy setup
Automatic SSL certificate management

Next Steps

After deploying your first SvelteKit app:

Custom Domain: Connect your domain in the dashboard
Environment Variables: Configure secrets and API keys
Team Access: Invite collaborators with role-based permissions
Monitoring: Set up alerts for performance and errors
API Integration: Connect to databases and external services

Ready to deploy? Create a free account →

PreviousRemix NextCustom Setups

Last updated 1 month ago