5 min read

NextJet

Renas Hassan

May 3rd, 2025

Overview

NextJet is a Next.js SaaS boilerplate and starter kit I built to help developers and founders launch their SaaS (Software-as-a-Service) applications much faster. It's a commercially available coding template that comes with a set of features that are commonly needed in SaaS applications.

The goal of NextJet is to save developers hundreds of hours and ensure they can focus on building their unique product features instead of spending time reinventing the wheel.

The problem & motivation

Building a SaaS application isn't easy, you're essentially coding an entire business. Setting up the skeleton for that requires careful consideration and planning.

This consumes a lot of time and prevents developers from building the core features related to their business idea. Most people quit working on their ideas after they realize how much time it is going to take them to set up the foundation.

Luckily, most SaaS apps share the same core features, authentication, payments, dashboards, and marketing pages. Therefore, you can use a pre-built coding template that has already solved these pain points.

I noticed most competitors don't emphasise developer experience, clean code, architecture, or best practices, which is a big problem if you want a scalable, maintainable SaaS that's built to last. Building your application on a spaghetti foundation is a recipe for disaster.

In my experience, coding an application is not the hard part, it's maintaining it and building something that is going to last and not drown in technical debt as the application grows. An application isn't rigid, it evolves alongside business requirements, so we need a structure that supports that flexibility.

NextJet's unique selling point is the strong focus placed on an excellent developer experience, a scalable and maintainable architecture, and a clean, fully typed codebase that is easy to understand and extend.

Key features & functionality

NextJet comes packed with important SaaS features:

Authentication: Google & Github OAuth, plus magic link login.
Payments: Pre-built integrations for Stripe and Lemon Squeezy to accept payments, manage subscriptions and offer a billing portal.
Role-based access control: Easily protect sensitive resources with the built-in role-based access control (RBAC) system.
Emails: Send transactional and marketing emails.
User Dashboard: Allows users to manage their profile and billing information.
Super Admin Dashboard: For managing users, viewing analytics, and user impersonation.
Content: MDX-based Blog and documentation sections with custom components.
Marketing: High-converting landing page template.
Onboarding flow: A built in, customizable flow to help users get started.
Documentation: Easy-to-follow docs for setting up NextJet.

Marketing page

Pre-built components and a proven high-converting layout to maximize sales.

User dashboard

Customizable onboarding flow, profile page, billing portal to manage your subscription.

Admin dashboard

Allow admin users to manage and track the performance of the application.

View user analytics
Impersonate users
Ban users
Delete users

Blog & documentation

Pre-built blog and documentation sections which allows you to write your own content in MDX format.

Tech stack

I chose a tech stack that is both modern and widely loved by developers; one that lets us move fast and enjoy a great developer experience.

Core: Next.js, Turborepo, TypeScript
Frontend: React, Tailwind CSS, shadcn ui, React Query
Backend: tRPC, Prisma (ORM)
Database: PostgreSQL (default, adaptable via Prisma)
Payments: Stripe, Lemon Squeezy
Email: Resend
Code Quality: ESLint, Prettier, Husky

Challenges & learnings

One of the biggest hurdles was designing NextJet to be highly extensible, flexible, modular, and customizable to support a wide range of use cases. When you're building a typical SaaS product, you already have a specific use case in mind, so you can tailor the app around those specific needs. But creating a general-purpose template that can accommodate many different use cases? That's a different kind of challenge.

I had to balance abstractions and design patterns against the risk of over-engineering, which could slow down development for end-users. The goal was a robust foundation that supported quick development cycles.

As engineers, we need to think ahead - not just about what the system needs today, but what it might need in the future. That kind of thinking helps us structure our code in a way that's flexible and maintainable.

But there's a catch.

If we try to design for every possible future use case, we risk over-engineering the codebase. That usually leads to extra layers of abstraction, more complexity, and ironically, a system that's harder to change. It sounds like you're making the code flexible, but in reality, you're making it rigid and harder to work with.

On the flip side, if we don't think about the future at all, we might under-engineer things. Then when requirements change (which they will), it becomes painful to refactor or extend the code.

So what's the sweet spot? It's all about balance. We should make informed decisions based on what's likely to happen - not what might happen. And the best way to do that? Ask questions. Talk to stakeholders. Get a sense of which future use cases are actually on the horizon and which are just nice-to-haves.

I learned that, in the majority of cases, the YAGNI principle applies, which stands for:

You Aren't Gonna Need It

Don't add functionality unless you actually need it. In other words:

Don't write code today for a problem you might never have tomorrow.

Only break this rule when:

You have confirmed requirements, not assumptions.
You've validated the need through stakeholder conversations.

That way, we can keep the code clean, simple, and adaptable - without going overboard in either direction.

My main takeaway: keep things simple for as long as possible, and only introduce complexity when it's absolutely necessary.

Outcome & links

The outcome was a robust, clean, scalable Next.js SaaS boilerplate that has received a lot of positive feedback from the community & users.

Website: https://www.nextjet.dev/
Documentation: https://www.nextjet.dev/docs

On this page