Provided as a Rails engine; after running bundle add kern, rails generate kern:install, and rails db:migrate, it is ready to use
kern — Rails SaaS Template
By Rails-Designer
Kern is a Rails engine that provides foundational features for SaaS applications, including authentication, multi-tenancy, team invitations, Stripe subscription billing, and common view components.
Explore the design
Compare the page layouts and mobile experience. Open any screenshot for a closer look.
Actual screenshot captured by the server browser.
All pages & views 2
Screenshots show visual appearance; interactive behavior may differ.
What stands out
A quick read of the recorded project description.
Built-in authentication, registration, and user settings, based on Rails' built-in authentication generator
Multi-tenant model: a Workspace is created at registration, users are associated through Member, and a Member can hold multiple Roles for authorization checks
Integrates Stripe subscription billing; plans are configured in config/configurations/plans.yml
Provides a form builder, basic view components, a dashboard layout with a collapsible sidebar, and a Turbo Stream notify helper
Includes a Sluggable concern and configuration wrapping based on config_for
Template Details
Kern is distributed as a Rails engine (gem); once installed, it provides the foundational modules commonly needed by SaaS products. It implements registration and login based on Rails' built-in authentication generator, and supports updating a user's email and password. For multi-tenancy, a Workspace record is created at registration; users join through a Member join table, and a Member can hold multiple Roles used for authorization checks (e.g., Current.member.has_role? :owner). Team invitations allow adding users to a Workspace, adjusting roles, or removing members. Billing and subscriptions are based on Stripe, implemented following Rails Designer's Stripe Billing approach; plans must be configured in config/configurations/plans.yml, and the Stripe API key and signing secret must be placed in credentials.
For interface and developer experience, Kern provides application/dashboard layouts (including a collapsible left sidebar), a form builder (with input helper methods), basic components (container, section, heading, enhanced dialogs, flash messages), and a Turbo Stream notify helper. It also includes a Sluggable concern for querying by slug instead of primary key, and configuration wrapping based on Rails config_for.
Note: The README explicitly marks Kern as heavily under development (WIP); some features are not yet included in the listed inventory, and the developer experience may not be fully polished. The project uses Standard to format Ruby code and Minitest for testing.
Is it right for your project?
Use Cases
- Quickly setting up authentication, registration, and user settings flows for a Rails application
- Implementing multi-tenancy and role-based access control with Workspace and Member models
- Integrating Stripe subscription billing and managing user subscriptions by plan
- Implementing team invitations, role adjustments, and member removal within the application
- Reusing ready-made form builders, dialogs, flash messages, and dashboard layouts
Suitable For
- Teams building SaaS products with Rails who want to skip foundational module development
- Developers willing to work on an engine that is heavily under development (WIP)
- Projects that need common SaaS foundations such as multi-tenancy, role-based permissions, and Stripe subscriptions
- Developers who prefer Minitest and Standard code style and are willing to read the source to make adjustments
Getting started & customization
Use these recorded setup notes alongside the repository instructions for your chosen version.
- 1
Add the dependency via bundle add kern, then run rails generate kern:install and rails db:migrate
- 2
Set the root route in config/routes.rb, for example root "dashboard#show"
- 3
Before using Stripe billing, configure plans in config/configurations/plans.yml and add the Stripe API key and signing secret to credentials
- 4
To customize registration, login, and similar features, run bin/rails generate kern:feature; use --help to view generator help
- 5
For icon support, run bin/rails generate rails_icons:install --libraries=phosphor to enable Rails Icons
License & source material
Usage conditions & limitations
Free to use · keep license noticeThis entry covers the free version in the public repository under the MIT license; the free scope is the code of that version and does not imply that external services or third-party assets are free.
Must comply with when using
- You may use, modify, commercialize, and distribute the code of this version for free.
- When distributing copies or substantial portions of the code, retain the original author's copyright notice and the full MIT license notice.
- The code is provided as is; warranties and limitations of liability are governed by the original license and applicable law.
Additional costs & items to verify
- Using billing and subscription features requires registering your own Stripe account and configuring the Stripe API key and signing secret in Rails credentials; this is an external service dependency.
- The project is heavily under development (WIP); the developer experience may not be fully polished and it should not be considered production-ready.
- Some features listed in the README are not actually included in the project yet; verify against the source before use.
- Demo images, fonts, icons, and other third-party assets must be checked against their respective licenses; the code's MIT license alone cannot be used to judge them.
- External services such as domains, hosting, databases, payments, or AI may incur additional charges.
View Original Text Basis
Permission is hereby granted, free of charge
Original License Text
add your Stripe API key and Signing secret to your credentials
Original README
Kern is heavily WIP, while most features are solid, the DX might be a bit less so.
Original README
https://github.com/Rails-Designer/kern/blob/main/MIT-LICENSEhttps://github.com/Rails-Designer/kern/blob/main/README.mdNot all features listed below are part of Kern just yet.
Original README
Compiled by DeepSeek based on repository license and README ·2026-10-02. Results only cover the materials read; dependencies, images, fonts, and subsequent term changes are subject to their respective original texts.
Project checks & description sources
Template Information
- Source platforms
- GitHub
- Documentation and maintenance reference score
- More documented · 88 / 100
- Technologies
- Rails
- Website type
- SaaS · Starter
How this score is calculated
Our heuristic uses license records (up to 30), a demo link (12), a preview (10), stars (15), recorded maintenance (15), description completeness (8), feature records (5) and classification data (5). It is not a code, security or performance test, or a Google score. A link does not establish tested functionality.
What to verify for this project
- Repository update recorded
- 2026-02-11
- Screenshot last checked
- 2026-10-02
A demo link is listed. Check it with your own content and viewport sizes; its presence does not confirm that forms, authentication or payments work.
The catalog identifies Rails as the primary stack. Check the actual dependency manifest and lockfile for versions and hosting requirements. These notes use recorded metadata, not a code audit or a deployment test.
Use a selection guide →How this description was prepared
AI-assisted description based on catalog records and repository material. Repository authors are not automatically the reviewers of this description.
Automatically checked against source and license rules; no manual editorial review.
Inspect the recorded source material
SHA-256: f496db80e3c1c0c8ba80cd0c4d14043a96de4347fb576b30e1c997f3ccb3c403
2026-10-02T19:06:02.702Z
Source file / repository# Kern
Rails engine that handles the SaaS foundation: authentication, team invitations, subscription/billing, and common partials. Skip the boilerplate and start shipping the actual product.
> [!NOTE]
> Kern is heavily WIP, while most features are solid, the DX might be a bit less so.
<table>
<tr>
<td>
<a href="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/kern__auth.jpg" target="_blank">
<img src="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/kern__auth.jpg" alt="Authentication" width="400">
</a>
</td>
<td>
<a href="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/kern__dashboard.jpg" target="_blank">
<img src="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/kern__dashboard.jpg" alt="Dashboard" width="400">
</a>
</td>
<td>
<a href="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/kern__subscriptions.jpg" target="_blank">
<img src="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/kern__subscriptions.jpg" alt="Subscriptions" width="400">
</a>
</td>
</tr>
</table>
<a href="https://railsdesigner.com/" target="_blank">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/logo-dark.svg">
<source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/logo-light.svg">
<img alt="Rails Designer" src="https://raw.githubusercontent.com/Rails-Designer/kern/HEAD/.github/logo-light.svg" width="240" style="max-width: 100%;">
</picture>
</a>
**Sponsored By [Rails Designer](https://railsdesigner.com/)**
> **kern** (Dutch/German, noun) — core, nucleus, foundation. The essential element at the center of something; the foundational part upon which everything else is built.
## Quickstart
```bash
bundle add kern
rails generate kern:install
rails db:migrate
```
## Installation
Add Kern to your Gemfile:
```bash
bundle add kern
```
Run the install generator:
```bash
rails generate kern:install
```
Run migrations:
```bash
rails db:migrate
```
Set your root route in `config/routes.rb`:
```ruby
root "dashboard#show"
```
## Usage
Kern works out of the box after installation. All features are available immediately.
### Generators
If you want to customize any available feature (e.g. sign up, log in, etc.), you can run: `bin/rails generate kern:feature`.
Append `--help` to see the generator's help.
## Included
Kern has all the foundational features for a SaaS built-in, so you can skip the boilerplate and ship your actual product.
> [!NOTE]
> Not all features listed below are part of Kern just yet.
### Authentication
Built on Rails' authentication generator.
### Sign up
Create an account for your app using email address and password.
### User settings
Update user's email and password.
### Multi-tenancy
By default a `Workspace` record is created upon sign up. Each `User` is associated to it using a `Member` join table. Each `Member` can have multiple `Role`'s you can use to authorize if they should have access (`Current.member.has_role? :owner`).
### Billing & subscriptions using Stripe
Following [Rails Designer's Stripe Billing set up](https://railsdesigner.com/saas/billing-with-stripe/), offer subscriptions right away. Just update `config/configurations/plans.yml` and add your Stripe API key and Signing secret to your credentials.
### Team invitations
Add more users to your `Workspace`, update roles or remove them again.
### Form builder
Pulled from [Rails Designer's Components](https://railsdesigner.com/components/), the included Form Builder lets you quicly build beautiful forms. Including a magic `input` helper that works like this:
```erb
<%= form_with url: session_path do |form| %>
<%= form.input :email_address, required: true %>
<%= form.input :password, required: true %>
<% end %>
```
### Component helper
Some basic components are included like:
- container; keep all your app's content in check
- section; easily divide up your screens in sections
- heading; have consistent headings for each screen
- enhanced dialog element (works with Turbo Frames and, includes `centered` or a `drawer` variants)
- flash messages (notifiy your users from the bottom-right)
These are built using vanilla Rails, as [described in this article]() (`component` helper included).
### Application/dashboard layout
A clean, minimal (application) layout is included with a (collapsible sidebar to the left)
### Turbo Stream `notify` helper
When using Turbo Stream responses, use `turbo_stream.notify "Updated"` to notifiy user on a successful request.
## Rails Icons support
The application/dashboard layout and the Form Builder have optional support for [Rails Icons](https://github.com/Rails-Desiger/rails_icons). Run `bin/rails generate rails_icons:install --libraries=phosphor` to enable them.
### Sluggable concern
If you do not want to expose the record's primary key, use the `Sluggable` concern. Include it in the model, make sure it has a (unique) `slug` column, and look up records using `ModelName.sluggable.find(params[:id])`.
### Configuration
Little syntactic sugar on top of Rails' `config_for` as explained [in this article](https://railsdesigner.com/saas/configuration/). Keep configuration together in, e.g. `config/configuration/urls.yml` and call each value like `Config::Urls.docs`.
## Contributing
This project uses [Standard](https://github.com/testdouble/standard) for formatting Ruby code. Minitest for testing. Please run `rake` before submitting pull requests.
## License
Kern is released under the [MIT License](https://opensource.org/licenses/MIT).
Explore similar templates
Compare previews and descriptions within the same stack and category.

react-starter-kit
A full-stack Inertia.js starter with a Rails backend and React + TypeScript frontend, generated by inertia-rails/generator and automatically synced.
Rails · Starter

rails-tabler-starter
A free, open-source Ruby on Rails backend starter using Tabler (Bootstrap 5) with Hotwire/Turbo.
Rails · Admin dashboard

plutonium-core
Plutonium is a Rails-based admin and starter template that uses generators to write CRUD, authentication, authorization, multi-tenancy, portals, search and filtering, and bulk actions directly into project code.
Rails · Admin dashboard

ace-template
Ace Template is a Rails application template applied via rails new, supporting interactive mode and command-line options, with SQLite, Postgres, and MySQL support, Tailwind or Bootstrap styling, and deployment instructions for Kamal, Fly.io, and Heroku.
Rails · Starter

rails-react-starter
Rails React Starter is an MIT-licensed starter that pairs a Rails JSON API backend with a React frontend, including TailwindCSS and Docker configuration.
Rails · Starter

SknServices
SknServices is a Rails 5 starter application focused on authentication and authorization, demonstrating content-level permission models through both XML files and a PostgreSQL database.
Rails · Starter
