Building a SaaS MVP in 2 Weeks with Rails

Two weeks. That's the timeline between I have a SaaS idea and I have paying users if you know what to prioritize and what to ignore.

I've guided founders through this process, and the pattern is remarkably consistent. Here's the exact blueprint I use.

---

The Philosophy

Before we get into code, understand this: your first MVP is not supposed to be perfect. It's supposed to test whether anyone will pay for what you're building.

Every feature you add beyond the core delays that test. Every week you spend polishing is a week you're not learning from real customers.

Launch fast. Listen. Iterate.

---

Week 1: The Foundation

Day 1-2: Authentication & User Model

Skip building authentication yourself. It's a solved problem. Rails 7 includes a built-in authentication generator:

rails generate authentication

This gives you:

• Session management
• Password reset flow
• A clean Current.user pattern
• Secure defaults

Add a simple subscribed boolean to the users table for now. You'll upgrade to proper billing later.

rails generate migration AddSubscribedToUsers subscribed:boolean default:false
rails db:migrate

That's all you need for day one.

Day 3-4: The Core CRUD

Build exactly one resource. The thing users will pay for.

If you're building a project management tool, build Project. If it's an analytics dashboard, build Report. If it's a scheduling app, build Appointment.

rails generate scaffold Project name:string description:text user:references
rails db:migrate

Then add basic authorization to ensure users only see their own data:

# app/controllers/projects_controller.rb
def index
  @projects = current_user.projects
end

def create
  @project = current_user.projects.build(project_params)
  # ...
end

That's it. No complex permissions. No sharing. No teams. Just a user and their stuff.

Day 5: Payments

This is where most founders get stuck. They spend a week researching payment providers and building subscription logic.

Don't. Use the pay gem from Basecamp:

# Gemfile
gem "pay", "~> 7.0"
gem "stripe", "~> 10.0"

Run the installer:

bundle install
rails pay:install:migrations
rails db:migrate

Add the Pay methods to your User model:

# app/models/user.rb
class User < ApplicationRecord
  pay_customer
end

Now create a simple pricing page. Add a button that creates a Stripe Checkout session:

# app/controllers/subscriptions_controller.rb
def create
  checkout_session = Current.user.payment_processor.checkout(
    mode: "subscription",
    line_items: "price_123456789", # Your Stripe price ID
    success_url: success_url,
    cancel_url: cancel_url
  )

  redirect_to checkout_session.url, allow_other_host: true
end

That's it. You're ready to charge real money.

---

Week 2: Launch Readiness

Day 6-7: Background Jobs

You'll need background jobs for:

• Sending welcome emails
• Processing webhooks
• Generating reports
• Any task that takes more than a few seconds

Rails 8 includes solid_queue. No Redis required. No additional services.

# app/jobs/welcome_email_job.rb
class WelcomeEmailJob < ApplicationJob
  queue_as :default

  def perform(user_id)
    user = User.find(user_id)
    UserMailer.welcome(user).deliver_now
  end
end

Call it after user signup:

WelcomeEmailJob.perform_later(@user.id)

In production, run the job processor:

bin/jobs

One less dependency to manage.

Day 8-9: Admin Panel

You will need to see user data. You will need to fix accounts. You will need to issue refunds.

Build a quick admin panel. Don't build it from scratch. Use avo:

# Gemfile
gem "avo", "~> 3.0"

bundle install
rails avo:install
rails db:migrate

Avo generates a clean admin interface from your existing models. Add a link to your admin dashboard:

# config/routes.rb
namespace :admin do
  resources :users
  resources :projects
end

Protect it with authentication:

# app/controllers/admin/application_controller.rb
class Admin::ApplicationController < ActionController::Base
  before_action :authenticate_admin_user!

  private

  def authenticate_admin_user!
    redirect_to root_path unless Current.user&.admin?
  end
end

Thirty minutes of work. Days of saved time later.

Day 10-11: Monitoring & Error Tracking

Don't wait for users to report bugs. Add error tracking on day one.

Sentry (free tier):

# Gemfile
gem "sentry-ruby"
gem "sentry-rails"

bundle install

# config/initializers/sentry.rb
Sentry.init do |config|
  config.dsn = ENV["SENTRY_DSN"]
  config.breadcrumbs_logger = [:active_support_logger, :http_logger]
end

Health check: Rails 7 includes /up out of the box. Use it.

Basic logging: Write logs to stdout. Your deployment platform (Fly.io, Render) will capture them.

Day 12-13: One Differentiator

You have a working SaaS. Authentication works. Billing works. Users can create their core resource.

Now add one thing that makes your product different from every other option.

Examples:

• CSV import/export for their data
• Real-time updates with Turbo Streams (no extra JavaScript)
• A simple API for power users
• Webhook notifications
• Slack integration

Pick one. Implement it well.

Do not add:

• AI features (unless that's your core product)
• Mobile apps (PWAs work fine)
• Team collaboration (add it later)
• Anything that takes more than two days

Day 14: Launch

Deploy to production. I recommend Fly.io or Render for simplicity.

fly launch
fly deploy

Set your environment variables:

fly secrets set STRIPE_API_KEY=sk_live_xxx
fly secrets set STRIPE_WEBHOOK_SECRET=whsec_xxx
fly secrets set SENTRY_DSN=https://xxx@sentry.io/xxx

Now find your first customers:

1. Your network. Post on LinkedIn. Email former colleagues. Tell everyone what you built.
2. Communities. Find subreddits, Slack groups, or Discord servers where your target customers hang out.
3. Direct outreach. Find 20 people who might need your solution. Email them personally. Offer a discount.
4. Product Hunt. Launch on Product Hunt. It's not what it used to be, but it still drives initial traffic.

Give your first five customers a 50% lifetime discount. Ask them for feedback in exchange. Listen carefully. Iterate.

---

The Gem Stack Summary

source "https://rubygems.org"
ruby "3.2.0"

gem "rails", "~> 7.2"
gem "pg", "~> 1.5"
gem "puma", "~> 6.0"

# Authentication & Billing
gem "pay", "~> 7.0"
gem "stripe", "~> 10.0"

# Admin
gem "avo", "~> 3.0"

# Background Jobs
gem "solid_queue", "~> 1.0"

# Monitoring
gem "sentry-ruby", "~> 5.0"
gem "sentry-rails", "~> 5.0"

# Frontend
gem "importmap-rails", "~> 2.0"
gem "stimulus-rails", "~> 1.3"
gem "turbo-rails", "~> 2.0"
gem "tailwindcss-rails", "~> 2.0" # or bootstrap

# Assets
gem "propshaft", "~> 1.0"

Run bundle install and you're ready.

---

What You Should Not Build

Feature	When to Add
User roles and permissions	When you have paying teams
Native mobile app	Never (PWA is fine)
Custom analytics	Never (use PostHog or Mixpanel)
Email marketing system	Never (use Mailchimp or ConvertKit)
Multi-tenancy	After 10 paying customers
API for third parties	When someone asks for it and pays
White labeling	After 50 paying customers
SSO (Single Sign-On)	When an enterprise customer demands it

Each of these features is a trap. They sound important. They feel like real engineering. But they don't help you find product-market fit.

---

The Mindset

The most successful founders I've worked with share one trait: they ship fast and listen carefully.

They don't fall in love with their code. They fall in love with the problem they're solving.

Every morning, ask yourself: What's the smallest thing I can build today that moves me closer to paying users?

Then build it. Ship it. Talk to customers. Repeat.

---

What's Next

You have a working SaaS. You have paying users. Now what?

1. Fix what's broken. Your first users will find bugs. Fix them quickly.
2. Add what's missing. They'll ask for features you didn't think of. Build the ones that multiple users request.
3. Raise prices. If people are paying, you're probably charging too little.
4. Write about it. Share your journey. It attracts customers and talent.

---

Next post: Integrating React with Rails: When and How