Getting Started

Everything you need to go from zero to a running SaaS app in under 5 minutes.

Create Your App

npx svelar new my-app
cd my-app
npm run dev

That's it. The new command installs dependencies, generates .env with secure random APP_KEY and INTERNAL_SECRET, runs migrations, and seeds the database. You now have a complete SaaS starter with authentication, dashboard, admin panel, teams, API keys, background jobs, and more — all pre-configured and ready to go.

By default, projects use a DDD modular structure (src/lib/modules/{domain}/). If you prefer a traditional flat layout, use --flat:

npx svelar new my-app --flat   # src/lib/models/, src/lib/services/, etc.

What You Get Out of the Box

When you run npx svelar new, Svelar scaffolds a full-featured application. Here's everything that's included and working from day one:

Authentication (Ready to Use)

All auth pages are pre-built with styled forms and validation. Passwords are hashed with scrypt (zero dependencies). Sessions are signed cookies stored in the database so they survive server restarts.

User Dashboard (Ready to Use)

Admin Panel (Ready to Use)

The admin panel at /admin has 7 tabs:

API Endpoints (Ready to Use)

These API routes work immediately after running migrations:

Auth:
  POST /api/auth/register      — Create account
  POST /api/auth/login         — Login (session cookie)
  POST /api/auth/logout        — Logout
  GET  /api/auth/me            — Current user

Content (example):
  GET  /api/posts              — List published posts
  POST /api/posts              — Create post (auth required)
  GET  /api/posts/:id          — Get post
  PUT  /api/posts/:id          — Update post (owner/admin)
  GET  /api/posts/mine         — Current user's posts

Admin:
  GET  /api/admin/users        — List users
  PUT  /api/admin/users        — Update user role
  DELETE /api/admin/users      — Delete user
  POST /api/admin/roles        — Create role
  DELETE /api/admin/roles      — Delete role
  POST /api/admin/permissions  — Create permission
  DELETE /api/admin/permissions — Delete permission
  POST /api/admin/role-permissions    — Assign permission to role
  POST /api/admin/user-roles         — Assign role to user
  POST /api/admin/user-permissions   — Grant direct user permission
  GET  /api/admin/export       — Export data

Real-time:
  GET  /api/broadcasting/:channel — SSE subscription

System:
  GET  /api/health             — Health check

Background Jobs (Pre-configured)

These jobs are scaffolded and ready to dispatch:

Scheduled Tasks (Pre-configured)

These cron tasks run automatically when you start the scheduler:

UI Components (Pre-installed)

Svelar scaffolds projects with shadcn-svelte — a comprehensive component library with 50+ components including Dialog, Dropdown, Select, Combobox, Calendar, Sheet, Command Palette, Data Table, and more. All components are installed at $lib/components/ui/ and ready to use.

Dark mode is supported out of the box via mode-watcher. Import components from $lib/components/ui/:

import { Button } from '$lib/components/ui/button';
import * as Card from '$lib/components/ui/card';

Svelar also ships its own minimal components (@beeblock/svelar/ui) used internally by the dashboard and admin panel: Button, Card, Input, Label, Badge, Alert, Avatar, Tabs, Separator, Icon, and Toaster.

You're not locked into shadcn-svelte — use any CSS framework or component library you prefer.

Internationalization (Pre-configured)

Three locales ready out of the box: English, Portuguese, Spanish. A LanguageSwitcher component is in the layout. All UI text, error messages, and validation messages are translatable.

Real-time Broadcasting (Pre-configured)

SSE-based real-time events. The layout already subscribes to a notifications channel and displays incoming events as toast notifications. Public, private (auth required), and presence (user metadata) channels are supported.

Step-by-Step Setup

1. Environment Variables

npx svelar new automatically generates a .env file with secure random APP_KEY and INTERNAL_SECRET. No manual setup needed.

To regenerate your app key at any time:

npx svelar key:generate

For existing projects or if you need to recreate .env:

cp .env.example .env
npx svelar key:generate

2. Run Migrations

If you used npx svelar new, migrations and seeding already ran automatically. For manual setup:

npx svelar migrate

This creates the database tables: users, posts, sessions, roles, permissions, audit logs, notifications, failed jobs, and all pivot tables.

Check what migrations ran:

npx svelar migrate --status

3. Seed Sample Data (Optional)

npx svelar seed:run

4. Start the Dev Server

npm run dev

Visit http://localhost:5173. You'll see the landing page. Click Register to create your first account.

5. Start the Scheduler (Separate Terminal)

npx svelar schedule:run

This starts the cron task runner. It checks every minute for tasks that need to run.

6. Start the Queue Worker (Separate Terminal)

npx svelar queue:work

This processes background jobs (welcome emails, data exports, etc.).

Your First 10 Minutes

After setup, here's what to try:

1. Register at /register — creates your account
2. Visit /dashboard — see the overview with stats and checklist
3. Create an API key at /dashboard/api-keys — try copying it and calling GET /api/auth/me with it
4. Create a team at /dashboard/team — invite a team member
5. Visit /admin — browse users, create roles, check system health
6. Create a post via API:

   curl -X POST http://localhost:5173/api/posts \
     -H "Content-Type: application/json" \
     -H "Cookie: svelar_session=<your-cookie>" \
     -d '{"title": "Hello World", "body": "My first post", "published": true}'

Building Your Features

Svelar handles the repetitive SaaS infrastructure. You focus on your core business logic.

Generate Domain Code

# Create a new domain module (e.g., invoices)
npx svelar make:model Invoice --module=billing
npx svelar make:controller Invoice --module=billing
npx svelar make:service Billing --module=billing --crud
npx svelar make:repository Invoice --module=billing --model=Invoice
npx svelar make:schema Invoice --module=billing
npx svelar make:migration CreateInvoicesTable

# Create API routes
npx svelar make:route invoices --api --resource -c InvoiceController

# Create a background job
npx svelar make:job GenerateInvoicePdf

# Create a scheduled task
npx svelar make:task SendInvoiceReminders

# Create an event + listener (in the billing module)
npx svelar make:event InvoicePaid --module=billing
npx svelar make:listener NotifyCustomer --event=InvoicePaid --module=billing

Every generator creates files in the right location following the DDD module structure. Run npx svelar migrate after creating migrations.

The Pattern

For any new feature, the workflow is:

1. npx svelar make:model + make:migration   → Define your data
2. npx svelar migrate                        → Create the table
3. npx svelar make:schema                    → Define the contract (Zod types)
4. npx svelar make:controller + make:service → Handle requests + business logic
5. npx svelar make:route                     → Wire up API endpoints
6. Build your UI in src/routes/              → Svelte pages

Core Modules Reference

Svelar ships 35+ modules. Here's what each one does and when you'll use it:

You'll Use Every Day

You'll Use for Business Logic

You'll Use for Infrastructure

You'll Use for SaaS Features

You'll Use for Developer Experience

Built-in Email Templates

These templates are registered and ready to use with EmailTemplates.render():

Pre-configured Security

All of this is enabled by default when you use createSvelarApp:

Production Deployment

When you're ready to deploy:

# Generate Docker files
npx svelar make:docker

# Build and start
docker compose up -d --build

# Run migrations in the container
docker compose exec app npx svelar migrate

# Seed data
docker compose exec app npx svelar seed:run

This sets up: your app (clustered via PM2), PostgreSQL, Redis, queue workers, scheduler, and optionally Soketi (WebSockets), Gotenberg (PDFs), and RustFS (S3-compatible storage).

See the Production Checklist for the full list.

What You Bring

Svelar handles the infrastructure. You bring:

• Your API keys — Stripe, Postmark/Resend, analytics, etc.
• Your business logic — the domain models, services, and rules unique to your product
• Your UI — Svelte pages for your product features (the layout, auth, and dashboard are already done)

Everything else — auth, sessions, roles, teams, API keys, jobs, scheduling, emails, file storage, audit logs, admin panel — is already built and waiting for you.

Next Steps

• Database — Customize migrations and switch to PostgreSQL
• Models & ORM — Define your domain models
• Controllers & Routing — Build your API
• Authentication — JWT, refresh tokens, request signatures
• Architecture — DDD module boundaries and patterns
• SaaS Guide — Multi-tenancy, billing, and production deployment

Svelar — The Laravel of SvelteKit. Build your SaaS, not your infrastructure.