Source: github.com/thedevdojo/wave Core features: Laravel (latest) + Livewire Auth: Laravel Breeze (email, OAuth) Billing: Stripe via custom implementation Admin panel: Complete Voyager-based admin Blog: Full blog with categories, tags, authors Themes: Multiple design themes API tokens: Personal access tokens for API integration Notifications: In-app and email Announcements: Product update notifications User profile and settings Changelog/updates system ---

Wave Review 2026: Free Laravel SaaS Boilerplate

TL;DR

Wave is the most complete free Laravel SaaS boilerplate. It includes admin panel, blog, themes, API tokens, notifications, billing (basic), and an announcements system — all for free. The billing is less polished than Laravel Spark ($99/year), but Wave's breadth is exceptional for a free tool. Best for PHP developers who want a full application foundation.

What You Get (Free)

Source: github.com/thedevdojo/wave

Core features:

Laravel (latest) + Livewire
Auth: Laravel Breeze (email, OAuth)
Billing: Stripe via custom implementation
Admin panel: Complete Voyager-based admin
Blog: Full blog with categories, tags, authors
Themes: Multiple design themes
API tokens: Personal access tokens for API integration
Notifications: In-app and email
Announcements: Product update notifications
User profile and settings
Changelog/updates system

The Admin Panel

Wave uses Voyager, a comprehensive Laravel admin package:

// Wave admin — manage users, subscriptions, blog posts
// All via Voyager's CRUD interface
Route::group(['prefix' => 'admin'], function () {
    Voyager::routes();  // Auto-generates admin routes for all models
});

The admin includes:

User management (view, edit, delete, impersonate)
Subscription status overview
Blog post management
Settings configuration
Role and permission management

No custom admin code needed — Voyager provides it.

The Theme System

Wave ships with multiple themes that can be swapped:

// config/wave.php
return [
    'show_changelog' => true,
    'billing_plan' => 'recurring',  // recurring or lifetime
    'theme' => env('WAVE_THEME', 'anchor'),  // Swap themes
    'plans' => [
        [
            'name'           => 'Basic',
            'monthly_id'     => env('STRIPE_BASIC_MONTHLY_PRICE_ID'),
            'yearly_id'      => env('STRIPE_BASIC_YEARLY_PRICE_ID'),
            'features'       => ['5 Projects', '10GB Storage', 'Email Support'],
        ],
        [
            'name'           => 'Pro',
            'monthly_id'     => env('STRIPE_PRO_MONTHLY_PRICE_ID'),
            'yearly_id'      => env('STRIPE_PRO_YEARLY_PRICE_ID'),
            'features'       => ['Unlimited Projects', '50GB Storage', 'Priority Support'],
        ],
    ],
];

Themes change the entire marketing site and dashboard appearance. This is rare in boilerplates.

The Blog System

Wave's blog is fully-featured:

// Blog with categories, tags, and multiple authors
// app/Models/Post.php (extended from Wave)

class Post extends WavePost
{
    // Custom scopes
    public function scopeFeatured($query)
    {
        return $query->where('featured', true)->latest()->take(3);
    }
}

SEO meta tags, featured images, reading time, comment sections — all included.

Billing Limitations vs Spark

Wave's billing is functional but not as polished as Laravel Spark:

// Wave billing — simpler but limited
// Plans defined in config, not dynamically managed
// No per-seat billing
// No promo code system
// No PDF invoice generation (Spark has this)
// No Paddle support (Stripe only)

For simple subscription SaaS (one plan, one user), Wave's billing is sufficient. For complex billing (per-seat, usage-based, international), upgrade to Spark.

Wave vs Laravel Spark

Feature	Wave (Free)	Laravel Spark ($99/yr)
Admin panel	✅ Voyager	❌
Blog	✅	❌
Themes	✅	❌
Billing quality	⭐⭐⭐	⭐⭐⭐⭐⭐
Per-seat billing	❌	✅
Paddle support	❌	✅
Promo codes	❌	✅
PDF invoices	❌	✅
Maintenance	Good	Excellent (Taylor)

The pattern: Wave gives you the full application; Spark gives you sophisticated billing. Many teams use both.

Wave + Spark Together

The common Laravel SaaS setup for teams that need both completeness and billing quality:

Wave (free) → Application foundation
  + Laravel Spark ($99/yr) → Billing replacement
  + Custom admin extensions → Additional features

This gives you Wave's admin panel, blog, and themes plus Spark's per-seat billing and Paddle support. The integration requires some work but is documented in the community.

Who Should Use Wave

Good fit:

PHP/Laravel developers wanting a complete free foundation
Products where blog and content management are important
Teams who need admin panel without building it
Early-stage products where billing simplicity is fine
Developers who want to customize extensively (it's open source)

Bad fit:

Products needing sophisticated billing (teams, per-seat, Paddle)
JavaScript-first teams
Founders who need the fastest possible launch (more configuration required than ShipFast equivalents)

Final Verdict

Rating: 3.5/5

Wave is exceptional value — a complete Laravel SaaS application for free. The Voyager admin, blog system, and theme flexibility are features that paid boilerplates don't include. The billing limitations are real but acceptable for many products. For Laravel developers starting a content-heavy or admin-heavy SaaS, Wave is the best free starting point.

Getting Started

# Clone Wave
git clone https://github.com/thedevdojo/wave.git my-app
cd my-app && composer install && npm install

# Configure environment
cp .env.example .env
php artisan key:generate

# Set database, mail, and Stripe credentials in .env:
# DB_DATABASE, DB_USERNAME, DB_PASSWORD
# MAIL_MAILER=smtp (or use Resend via mailcoach)
# STRIPE_KEY, STRIPE_SECRET, STRIPE_WEBHOOK_SECRET

# Run migrations and seed
php artisan migrate --seed

# Start development
php artisan serve  # → localhost:8000
npm run dev        # Vite assets

Wave requires a MySQL or PostgreSQL database and a mail provider. The seeder creates a default admin user — log in at /admin with the credentials from the seeder output.

Extending Wave with Custom Models

Wave's model extension pattern keeps customizations clean:

// Extend Wave's built-in User model
namespace App\Models;

use Wave\User as WaveUser;

class User extends WaveUser
{
    protected $fillable = [...parent::$fillable, 'company', 'timezone'];

    // Add custom relationships
    public function projects()
    {
        return $this->hasMany(Project::class);
    }

    // Override billing check for custom logic
    public function hasActiveSubscription(): bool
    {
        return $this->subscribed('default') || $this->isAdmin();
    }
}

This pattern lets you add custom fields, relationships, and methods without modifying Wave's core files — making future updates easier to merge.

The Billing Setup

Wave's Stripe billing requires creating plans in both Stripe and Wave's config:

# 1. Create products/prices in Stripe dashboard
# 2. Add price IDs to .env
STRIPE_BASIC_MONTHLY_PRICE_ID=price_xxx
STRIPE_BASIC_YEARLY_PRICE_ID=price_yyy
STRIPE_PRO_MONTHLY_PRICE_ID=price_zzz

# 3. Plans auto-appear in Wave's pricing page from config/wave.php

The checkout flow redirects to Stripe Checkout and handles the webhook on return. Wave's billing doesn't support per-seat pricing or complex metered billing — for those requirements, replace Wave's billing with Laravel Cashier + Paddle for Merchant of Record (handles EU VAT automatically).

Key Takeaways

Wave is the most feature-complete free Laravel SaaS boilerplate — admin panel, blog, themes, and Stripe billing all included
For simple subscription billing (one price, one user), Wave's billing layer is sufficient; for complex billing, add Laravel Spark ($99/year)
The Wave + Spark combination gives you the best of both: Wave's application features + Spark's enterprise billing
Voyager admin auto-generates CRUD interfaces from your Eloquent models — no custom admin code needed for basic management
PHP/Laravel's convention-over-configuration gives Wave a lower customization floor than equivalent JavaScript boilerplates

Deploying Wave to Production

Wave requires a server runtime — Nginx or Apache + PHP-FPM — which means no Vercel deployment. The standard PHP deployment options in 2026:

Laravel Forge + DigitalOcean: Forge provisions and manages PHP servers ($12/month for the server, $15/month for Forge). Set up in under an hour with automatic deployments from GitHub. Includes Let's Encrypt SSL, queue workers, and cron management.

Ploi: Similar to Forge at a lower price ($3.99/month). Less feature-rich but sufficient for most Wave deployments.

Railway or Render: Both support PHP via Docker. Create a Dockerfile that runs PHP-FPM + Nginx, push to Railway or Render. Less Laravel-specific tooling than Forge but cheaper for low-traffic apps.

# Dockerfile for Wave
FROM php:8.2-fpm

RUN apt-get update && apt-get install -y nginx
RUN docker-php-ext-install pdo_mysql pdo_pgsql

COPY . /var/www/html
RUN composer install --no-dev --optimize-autoloader

COPY docker/nginx.conf /etc/nginx/sites-enabled/default
EXPOSE 80
CMD ["sh", "-c", "php-fpm -D && nginx -g 'daemon off;'"]

For teams accustomed to Next.js on Vercel, the PHP server setup has a higher operational overhead. Laravel Forge makes it manageable, but it's still more complex than a one-click Vercel deploy.

Laravel's Artisan Productivity

One underrated advantage of the Laravel/Wave stack is Artisan command generation. Scaffolding a new feature is faster than the equivalent in Node.js:

# Generate model, migration, controller, factory, seeder, policy
php artisan make:model Project -mcsfp

# Add to Wave admin (Voyager)
php artisan voyager:add_resources Project --read

# Generate mail class
php artisan make:mail ProjectShared

# Clear cache in production
php artisan config:cache && php artisan route:cache

The convention-over-configuration pattern means less time making architectural decisions. For small teams where speed of feature development matters, this productivity advantage is real and compounds over time.

Wave's Community and Long-Term Maintenance

Wave is maintained by the DevDojo team (Tony Lea) and has accumulated over 6,000 GitHub stars. The maintenance cadence is steady but not as tight as Taylor Otwell's work on Laravel Spark or the core Laravel framework. When a new major Laravel version ships, Wave typically catches up within a few months — important to check before adopting for a long-lived project.

The community forums at devdojo.com provide a reasonable support environment, and the GitHub issues tracker shows active engagement. That said, the community is dramatically smaller than the JavaScript boilerplate space. Expect to read source code for answers to non-standard questions rather than finding them on Stack Overflow.

One practical consideration: Wave uses Voyager as its admin panel, and Voyager itself has had periods of slower maintenance. If Voyager's update cadence drops, Wave's admin layer inherits that problem. Teams with complex admin requirements should budget time to evaluate Voyager's current state before committing.

When to Skip Wave

Wave is not the right tool in several common scenarios. If your team is JavaScript-first and only considering Wave because it's free, that's the wrong trade-off — the operational overhead of a PHP deployment (Nginx, PHP-FPM, queue workers) versus Vercel's one-click JavaScript deploys is real. Free doesn't mean cheap when you account for server management time.

If your product needs sophisticated billing from launch — per-seat pricing, prorated upgrades, Paddle for Merchant of Record tax handling — Wave's billing layer will feel like a constraint within weeks. Build on Laravel Spark or the Wave + Spark combination from the start rather than retrofitting billing later.

Wave's theme system is powerful but means you're operating within Voyager's design conventions. Teams with strong design requirements or who need to build a truly custom UI often find it faster to start from a plain Laravel installation than to work against Wave's theme assumptions.

Production Considerations

Wave ships with a development environment focused on MySQL, but production deployments have additional requirements. A proper Wave production stack in 2026:

The mail system needs a transactional email provider. Wave supports standard SMTP configuration — connect it to Resend, Postmark, or Mailgun by setting the MAIL_MAILER variables. The default PHP mail function is not reliable in production.

Queue workers are essential for any Wave deployment handling emails or billing events. Laravel's queue system is excellent, but it requires a persistent process managed by Supervisor or Laravel Horizon. Forge handles this automatically; manual VPS setups require configuring Supervisor yourself.

File storage defaults to the local filesystem. For multi-server deployments or any setup where the web server changes, configure FILESYSTEM_DISK=s3 and connect to AWS S3 or Cloudflare R2 for user uploads. Wave's Voyager admin allows media uploads, and local-disk storage breaks when you horizontally scale.

The boilerplate that works best is the one your team can productively extend. Documentation quality, community activity, and the clarity of the codebase architecture matter as much as the feature list when you're making the decision for a product you'll maintain for years.

Compare Wave with other Laravel starters in the StarterPick directory.

See our Laravel Spark review for the billing-focused alternative.

Browse best SaaS boilerplates for 2026 for the complete cross-framework comparison.

Review the best FilamentPHP SaaS boilerplates for another powerful Laravel admin approach.

The SaaS Boilerplate Matrix (Free PDF)