Uno — the only one you need to ship

Your SaaS, live in days.
Not months.

The boring 90% of every SaaS, already working under the hood. You focus on the one thing only you can build: your product.

PaymentsSign-insEmailsAdminJobsDeploys

One-time payment · Lifetime updates · Unlimited projects

your-saas — zsh
$ git clone uno my-saas && bin/setup
→ 5 databases ready · credentials generated
$ bin/dev
→ localhost:3000 — auth, billing, admin live
$ kamal deploy
→ https://my-saas.com — SSL, CDN, jobs. Done.
$
Rails 8.1Ruby 4.0PostgreSQLSolid Queue / Cache / CableHotwirePhlex 2Tailwind 4BunRails Event StoreStripeFlipperKamal 2

01 / The problem

The first 56+ hours of every SaaS are the same. And none of them are your product.

Auth — email, magic links, OAuth, JWT for the API~8 hrs
Stripe — checkout, portal, webhooks, plan resets~6 hrs
Admin panel — users, roles, impersonation, flags~12 hrs
Background jobs, emails, transactional templates~6 hrs
Push notifications, realtime, Slack alerts~6 hrs
Deploy — Docker, SSL, CDN, object storage~6 hrs
GDPR — cookie consent, legal pages, audit log~4 hrs
API hardening — encryption, rate limiting~8 hrs
Total, before your first real feature56+ hrs

Uno ships all of it — tested, documented, already working under the hood. You get to focus on the logic only your product can have. Start at the interesting part.

02 / What's inside

Everything already wired.

Not stubs, not TODOs — working features extracted from production apps, each with its own documentation.

Auth, every flavor

Magic links, one-time codes, Google & Apple sign-in, classic Devise. JWT with refresh-token rotation for the API. Signups gated behind a feature flag.

Stripe billing, wired

Checkout, customer portal, webhook handling, purchase models, and a daily job that resets monthly and weekly plans. Connect your keys and charge.

Full admin panel

Users with impersonation, roles with audit history, feature flags, moderation, bug reports, feature requests, changelog — plus a Cmd+K command palette.

Background jobs, no Redis

Solid Queue on its own Postgres database with the Mission Control dashboard mounted at /jobs. Recurring jobs and reminder sweeps included.

Email, push, Slack, realtime

Multi-channel notifications via Noticed: transactional email components, FCM push, ActionCable realtime sync, and Slack alerts — each behind a kill switch.

End-to-end encrypted API

RSA-OAEP + AES-256-GCM envelope encryption for mobile API payloads with key rotation. ActiveRecord encryption and rack-attack rate limiting on top.

Event sourcing built in

Rails Event Store on a dedicated database: domain events, sagas, CQRS read models, and a full audit trail. Browse every event at /res.

Architecture that scales

Domain contexts under app/core, application services on dry-rb, nine battle-tested base classes. New features follow a documented convention, not vibes.

Deploy on day one

Kamal 2 + Docker + Thruster. One command puts you in production with SSL, HTTP caching, and Cloudflare R2 object storage — optionally encrypted at rest.

Fast by default

Solid Cache, immutable asset caching, stale-while-revalidate headers, and Prosopite N+1 detection that fails the test suite before regressions ship.

AI infrastructure ready

RubyLLM multi-provider clients (OpenAI, Gemini, Grok, Qwen), usage logging, audit trail for LLM calls, and a generic tool-calling agent framework.

Mobile from the same codebase

Hotwire Native iOS shell ready to rename and sign, PWA with install prompt, and an offline-sync API reference implementation with tombstones.

03 / Architecture

Built to grow past the demo stage.

Most boilerplates hand you a pile of controllers. This one hands you an architecture: domain contexts, application services, domain events, and read models — so the code still makes sense at feature #50.

  • Event sourcing with Rails Event Store — every state change is a fact you can replay and audit
  • Application services on dry-rb monads — one entry point per use case, no fat controllers
  • CQRS read models for fast, denormalized queries
  • Minitest suite with system tests, factories, VCR — and an N+1 guard that fails the build
  • Pure-Ruby Phlex views — token-efficient for Claude Code & Cursor, refactorable like any Ruby
app/core/billing/application/activate_subscription.rb
class ActivateSubscription < ApplicationService
  def call(command)
    subscription = yield find(command.id)
    yield activate(subscription)

    publish(SubscriptionActivated.new(
      subscription_id: subscription.id
    ))

    Success(subscription)
  end
end

04 / Back office

The admin panel alone is worth a week of work.

Day one, you can support users, flip features, watch jobs, and audit everything — without writing a single admin view.

Users — impersonate, suspend, reset, sync
Roles with full audit history
Feature flags (Flipper UI at /flipper)
Jobs dashboard (Mission Control at /jobs)
Event browser (RES at /res)
Moderation queue with auto-unlock
Changelog posts & what's-new page
Bug reports & feature requests
AI usage, providers & LLM audit log
Emails with AI-assisted editing
Marketing dashboard & waitlist
Cmd+K command palette everywhere
👋

Hey, I'm Rafał.

I ship production Rails apps for a living. Uno isn't a weekend demo — it's extracted from real products with real users. Every feature in it exists because a real app needed it, broke without it, or paid for itself with it. I use it for every new product I start. Now you can too.

05 / Pricing

Pay once. Ship forever.

Launch pricing — goes up when the next feature batch lands.

Starter

$199$149one-time
  • Full template repository
  • 30+ per-feature docs
  • Unlimited projects
  • 1 year of updates
  • Community support
Get Starter access
Most popular

Complete

$299$199one-time
  • Everything in Starter
  • Hotwire Native iOS shell
  • Lifetime updates
  • All future features included
  • Priority support
Get Complete access

Final sale after access · Secure checkout · Instant delivery

06 / FAQ

Questions, answered.

What exactly do I get?

The complete Rails application repository, 30+ per-feature docs, the Hotwire Native iOS shell, and updates. Clone it, run bin/setup, and start building your product on top.

What's the tech stack?

Rails 8.1 on Ruby 4.0, PostgreSQL (five databases: primary, cache, queue, cable, events), Hotwire, Phlex 2 views, Tailwind 4, Bun for JS, Stripe, Rails Event Store, and Kamal 2 for deploys. No Redis, no Node runtime in production.

How many projects can I build with it?

Unlimited personal and commercial projects. The only thing you can't do is resell or redistribute the template itself.

Does it work with Claude Code and Cursor?

It's built for AI-assisted coding: AGENTS.md, documented conventions for every layer, and Phlex views that are pure Ruby — dramatically more token-efficient than ERB/HTML for coding agents.

Why Phlex instead of ERB?

Views are plain Ruby objects: componentized, testable, fast, and refactorable with the same tools as the rest of your code. And AI agents read and write them with far fewer tokens.

Do I need to be a Rails expert?

No. If you're comfortable with Rails basics you can ship with this. Every feature has its own doc explaining what it does, where it lives, and how to extend it.

How do I get updates?

The template lives in a git repository — pull new features and fixes whenever you want. Lifetime updates are included with the Complete tier.

What other costs should I expect?

A VPS from ~$6/month (Kamal deploys to any box), a domain, and Stripe's standard fees. No mandatory third-party SaaS subscriptions — jobs, cache, and websockets all run on Postgres.

Can I remove features I don't need?

Yes. Features are isolated in domain contexts under app/core and gated with Flipper flags — switch them off or delete the folder cleanly.

Is there a refund policy?

No. Paid digital access is delivered immediately and is final once granted — the same model as ShipFast and other boilerplate sellers. You must accept our Terms (including loss of the statutory 14-day withdrawal right) before checkout. Mandatory consumer rights still apply where the law requires.

Ship before your competitors
finish their auth flow.

56+ hours of plumbing, done. One command to production. Your idea deserves the head start.

One-time payment · Lifetime updates · Terms apply before checkout