GitHub Copilot Built My MRR Dashboard in One Session ($49)

Core Insight

A solo developer built a self-hosted MRR dashboard called MetricMint in one session with GitHub Copilot and listed it for sale at $49. The entire project — from schema design to React components to deployment — was generated by Copilot. No cursor, no Claude Code, no other AI tools. This is a pure GitHub Copilot case study demonstrating that a single AI coding assistant, when used effectively, can ship a complete, production-grade SaaS product in hours.

Project Background

The creator (known as "ibrh96-prog" on GitHub and Dev.to) is an indie developer who needed an MRR dashboard to track his own SaaS revenue. Instead of subscribing to yet another SaaS tool — many of which cost $20-50/month — he decided to build his own. The core insight was: "I don't need Stripe integration, bank sync, or team features. I just need to manually enter my revenue numbers and see trends."

This constraint-first thinking is what made the project feasible in a single session. By limiting scope to a single-user, self-hosted tool, the entire project became manageable for one person with one AI assistant.

The project is fully open source on GitHub (github.com/ibrh96-prog/metricmint), built with a modern TypeScript monorepo, and documented in detail on both Indie Hackers (June 2, 2026) and Dev.to. The creator explicitly credits GitHub Copilot as the sole AI coding tool used throughout the build.

Tool Stack

MetricMint represents a production-grade modern web stack, all scaffolded and written with GitHub Copilot's assistance:

The most interesting technical choice is the pnpm monorepo with shared packages. The creator noted that Copilot handled the cross-package TypeScript types and Zod schemas seamlessly — "I described the schema I needed — MRR entries, subscriber counts, churn tracking — and Copilot generated the full Drizzle ORM schema and Zod validation. I didn't write any of that by hand."

The developer explicitly stated he used only GitHub Copilot — no Cursor, no Claude Code, no other AI tools. This makes MetricMint a rare pure-Copilot case study.

Revenue Sources

MetricMint is sold as a one-time purchase at $49 — not a subscription. This pricing model is deliberate:

• $49 one-time for the self-hosted version (buyers get the code, deploy on their own Railway/Supabase)
• Open source on GitHub for those who want to self-deploy for free
• Indie Hackers post drives organic traffic and social proof

While exact sales figures aren't publicly disclosed, the project has gained significant attention:

• Featured on Indie Hackers front page (June 2026)
• Published as a detailed technical write-up on Dev.to
• Open-sourced on GitHub with stars and community engagement
• Covered by multiple indie hacker newsletters and aggregators

The business model here isn't about MRR — it's about productized open source: the code is free, but convenience costs $49. This model works particularly well for tools aimed at other developers who value their time. Setting up a self-hosted dashboard with all the integrations from scratch would take most developers 10-20 hours. At $49, MetricMint effectively values the developer's time at $2.50-5/hour — an easy sell.

Revenue signal strength: While the $49 price point means volume is needed for significant income, the project's visibility on Indie Hackers and Dev.to, combined with the GitHub open-source funnel, creates a sustainable passive income stream. For a product built in one session, the ROI per hour of development time is extremely high.

Replicable Steps

Here's exactly how this project was built, step by step — replicable by any developer with GitHub Copilot:

Step 1: Define constraints before writing any code

The creator started with clear constraints:

• Single-user only (no auth, no multi-tenancy)
• Manual revenue entry (no Stripe API, no bank sync)
• Self-hosted (buyer deploys on their own infra)
• One session timebox

This constraint-first approach is the single most important lesson. Without it, the project would have expanded into a multi-week build with authentication, payment integration, and team features. Constraints made it possible.

How to apply this: Before opening your editor, write down what your product WON'T do. Be ruthless. Every feature you exclude is hours of development you save.

Step 2: Describe the data model to Copilot

Instead of designing the database schema manually, the creator described the business requirements to Copilot in plain English:

"I need MRR entries with date, amount, subscriber count, and churn tracking. I want a 12-month trend chart. I need to calculate net MRR, month-over-month growth, churn rate, and ARPU."

Copilot generated the complete Drizzle ORM schema with proper PostgreSQL types, indexes, and relationships. It also generated the corresponding Zod validation schemas via drizzle-zod.

The key technique: Describe WHAT the data represents, not HOW to structure it. Let Copilot handle the implementation details.

Step 3: Scaffold the monorepo with pnpm workspaces

The project uses a monorepo structure with three shared packages:

• packages/db — Drizzle schema + database client
• packages/api — Express routes + TypeScript types
• packages/web — React app consuming shared types

Copilot handled the pnpm workspace configuration, TypeScript path aliases, and cross-package imports. The creator noted this was "the harder part" — getting the monorepo build working — but Copilot's TypeScript expertise made it manageable.

Step 4: Generate UI components with shadcn/ui + Copilot

With the data layer in place, the creator used Copilot to generate React components:

• Dashboard layout with cards for key metrics (MRR, growth, churn, ARPU)
• 12-month trend chart using Recharts
• Data entry form for manual revenue input
• Churn breakdown visualization

Each component was generated by describing the desired UI in comments:

// Create a dashboard card showing MRR with month-over-month change indicator
// Use shadcn/ui Card component with a green/red arrow for growth/decline

Copilot generated the full component including Tailwind styling classes.

Step 5: Deploy on Railway + Supabase

Deployment was straightforward since the project is a standard Express + React app:

1. Push the monorepo to GitHub
2. Connect Railway to the repo
3. Set up Supabase project with the Drizzle-generated schema
4. Configure environment variables

The entire deployment took under 30 minutes. Since MetricMint is self-hosted, each buyer follows similar steps on their own infrastructure.

Step 6: Launch with documentation

The creator wrote a detailed Indie Hackers post explaining the build process, then cross-posted to Dev.to with more technical depth. Both posts emphasized Copilot's role and included the tech stack breakdown. This transparency became the product's marketing — developers who read the posts became potential customers.

Key Workflow Pattern: Describe → Generate → Review → Iterate

The creator's workflow pattern with Copilot followed a consistent loop:

1. Describe the desired outcome in a comment or chat
2. Accept Copilot's suggestion (or choose from alternatives)
3. Review the generated code for correctness
4. Iterate by describing refinements

This tight feedback loop meant the developer never spent more than 30 seconds on any single piece of code. The entire session was a continuous flow of describing intent and reviewing output.

Risks & Pitfalls

Pitfall 1: Scope creep is the #1 killer

The biggest risk with AI-assisted development is losing discipline on scope. When Copilot can generate a full authentication system in 30 seconds, the temptation to add "just one more feature" is enormous. The MetricMint creator avoided this by writing constraints before touching any code.

Lesson: If you don't define what you're NOT building, AI will happily help you build everything — and you'll never ship.

Pitfall 2: Monorepo complexity

The pnpm monorepo architecture, while elegant, introduced complexity that nearly derailed the project. Cross-package TypeScript types, shared Zod schemas, and build tooling configuration required several iterations to get right. Copilot helped, but the developer still needed to understand the architecture to guide it.

Lesson: Start with a single-package setup. Only introduce monorepo structure when you actually need shared packages. The simplicity gain from a single package often outweighs the architectural purity of a monorepo for solo projects.

Pitfall 3: Copilot's context window limitations

GitHub Copilot works within a limited context window. For the dashboard page — which involved data fetching, state management, chart rendering, and multiple sub-components — the context was sometimes insufficient. The developer had to break the work into smaller chunks, generating each sub-component independently.

Lesson: Break complex features into files under 300 lines. Copilot works best with focused, single-responsibility files.

Pitfall 4: Pricing psychology for developer tools

At $49 one-time, MetricMint competes against free open-source alternatives (including its own GitHub repo). The conversion rate from free to paid is likely low. For developer tools, the "free for self-hosting, paid for convenience" model works, but it requires high traffic volume to generate meaningful revenue.

Lesson: If you're building for the same audience, consider a higher price point or a subscription model. Developer tools that save time (rather than providing unique features) have a natural price ceiling around $49-99 one-time.

Pitfall 5: Copilot-only vs. multi-tool approach

The developer used only Copilot, which meant relying on a single model's strengths and weaknesses. Many indie hackers now use a combination: Cursor for fast code editing, Claude Code for complex architectural decisions, and Copilot for completions and boilerplate. A multi-tool approach might have handled the monorepo complexity more smoothly.

Lesson: Don't be dogmatic about using a single AI tool. Different tasks benefit from different tools. Copilot excels at inline completions and boilerplate; Claude Code excels at architectural reasoning; Cursor excels at codebase-wide refactoring.

Why This Case Matters for AI Builders

MetricMint is significant not because of its revenue (modest, as a $49 one-time product) but because it demonstrates the lower bound of AI-assisted productivity. In one session — likely 4-8 hours — a single developer built and deployed a full-stack web application with:

• Type-safe database layer (Drizzle + Zod)
• REST API with validation
• React dashboard with charts
• Monorepo architecture
• Production deployment

Ten years ago, this would have been a 2-4 week project for a senior full-stack developer. Today, with GitHub Copilot, it's an afternoon project. The implications for indie hackers are profound: the barrier to shipping production software has collapsed.

The question is no longer "Can I build this?" but "Should I build this?" — and that's a much better problem to have.

Related Resources

• GitHub Copilot Hub — Complete guide to Copilot features, pricing, and workflows
• GitHub Copilot FAQ — Common questions about Copilot usage
• Build an AI Micro SaaS in 7 Days — Step-by-step guide to launching your own AI SaaS
• Copilot vs Cursor vs Claude Code Comparison — Which AI coding tool fits your workflow?

Sources: Indie Hackers (June 2, 2026), Dev.to, GitHub (ibrh96-prog/metricmint). Revenue and build details as reported by the creator.