Stop Rebuilding SaaS Infrastructure: A Next.js + Firebase Foundation Built for the Spark Plan

Femi Jazaniah Eguen — Tue, 11 Aug 2026 12:51:54 +0000

Every time I start a SaaS project, I find myself solving many of the same problems before I can work on the actual product.

Authentication.

User profiles.

Workspaces.

Memberships.

Roles and permissions.

Invitations.

Database security.

Audit logs.

Usage tracking.

Settings.

None of these problems are unusual. In fact, that's exactly the problem.

They are common enough that developers repeatedly rebuild them, but important enough that getting them wrong can create serious architectural and security problems later.

After going through this process repeatedly, I decided to build the foundation I wanted to start with.

That project became SaaSStinger Lite — a production-ready Next.js + Firebase SaaS foundation designed to handle the repetitive infrastructure so developers can spend more time building the product that makes their SaaS different.

And there was one requirement I considered particularly important:

SaaSStinger Lite is designed to be compatible with Firebase's free Spark Plan.

That means developers can start building and validating their SaaS without immediately needing to commit to paid Firebase infrastructure.

This article explains why I built it, the architecture behind it, and why I made those choices.

The problem with starting a SaaS from scratch

When people talk about building a SaaS, they often focus on the visible features.

A dashboard.

A billing page.

An analytics screen.

An AI feature.

A marketplace.

A project management system.

But before any of those features become useful, the application needs an underlying system.

Consider a simple SaaS where users belong to teams.

You now have several questions:

How does a user authenticate?
Where is their profile stored?
How does the application know which workspace they're using?
Can they belong to multiple workspaces?
Who owns a workspace?
What can administrators do?
What can regular members do?
How are invitations handled?
Can a member access another workspace's data?
How are those restrictions enforced in the database?
How do you record important actions?
How do you track usage?

The individual questions aren't necessarily difficult.

The difficulty comes from making all of the answers work together.

That's where a lot of development time disappears.

Authentication is only the beginning

Firebase Authentication makes authentication relatively straightforward.

A user signs up.

They sign in.

You receive an authenticated user.

That's useful, but authentication doesn't solve authorization.

Knowing that a user is user_123 doesn't tell you whether that user should be allowed to access workspace workspace_456.

That's where the architecture needs another layer.

SaaSStinger Lite separates the concepts of:

User → Membership → Workspace → Role → Permission

This gives the application a structure it can use consistently.

A user can authenticate independently of the workspace they are currently working in.

A membership connects the user to a workspace.

The membership contains the user's role.

The application can then use that relationship when determining what the user is allowed to access.

That distinction becomes increasingly important as a SaaS grows.

Multi-workspace architecture

One of the decisions I wanted to get right from the beginning was workspace architecture.

A common starting point is:

User
  ↓
Data

That works for many small applications.

But as soon as the application becomes team-oriented, the model changes.

A more useful structure becomes:

User
  ↓
Membership
  ↓
Workspace
  ↓
Workspace Data

Now the user doesn't directly own everything.

They have access through their membership in a workspace.

This creates a foundation for applications where:

one user can belong to multiple workspaces
each workspace has its own data
different users have different roles
workspace-level permissions can be enforced
users can be invited into existing workspaces

That model is much easier to extend than trying to retrofit teams into an application designed around a single-user architecture.

RBAC and authorization

SaaS applications frequently need different levels of access.

SaaSStinger Lite starts with three workspace roles:

OWNER
ADMIN
MEMBER

The names themselves aren't particularly important.

The architectural principle is.

Instead of scattering permission checks throughout the application, roles provide a consistent way to represent access levels.

For example:

OWNER
├── Manage workspace
├── Manage members
├── Manage settings
└── Full workspace access

ADMIN
├── Manage members
├── Manage workspace resources
└── Administrative access

MEMBER
├── Access permitted workspace resources
└── No administrative controls

The exact permissions of a real production application will depend on its requirements.

That's intentional.

A starter shouldn't try to predict every application's authorization model.

It should provide a sensible foundation that developers can extend.

Why authorization should not live only in the UI

This is one of the most important lessons when building multi-user applications.

Hiding a button isn't security.

For example:

{user.role === "ADMIN" && (
  <DeleteWorkspaceButton />
)}

can improve the user experience.

But it doesn't actually protect the operation.

A malicious or buggy client can still attempt to perform the underlying database operation.

Security needs to exist at the data-access layer as well.

That's particularly important with Firestore.

The application might decide that only an OWNER should be allowed to delete something, but Firestore must also enforce the appropriate access rules.

This creates a layered model:

UI
 ↓
Application authorization
 ↓
Firestore security rules
 ↓
Database

Each layer has a different job.

The UI communicates what the user can do.

Application logic handles authorization decisions.

Firestore rules provide an additional enforcement boundary around the data.

Why Firebase?

Firebase was a deliberate choice for SaaSStinger Lite.

I considered approaches that would require developers to assemble a separate API, database, authentication system, and authorization layer.

Instead, Firebase gives the foundation a combination of:

Firebase Authentication
Cloud Firestore
Firestore Security Rules
Managed infrastructure
A mature developer ecosystem

This allows developers to start building without first assembling and maintaining an entire backend platform.

But Firebase offered something else that was particularly important for this project.

Firebase Spark Plan compatibility

One of the biggest barriers for developers validating a new SaaS isn't always technical.

It's cost.

When you're still testing an idea, you may not know whether you'll have ten users, one hundred users, or zero users.

I didn't want SaaSStinger Lite to force developers into paid Firebase infrastructure simply because they wanted to start building.

That's why Firebase Spark Plan compatibility is a core consideration of SaaSStinger Lite.

The foundation is designed to work within the constraints of Firebase's free Spark Plan, giving developers a way to start building and validating their SaaS without immediately moving to a paid Firebase plan.

This makes SaaSStinger Lite particularly useful for:

indie hackers validating ideas
developers building side projects
early-stage SaaS founders
freelancers prototyping client products
teams testing an MVP

Of course, successful applications can eventually require paid infrastructure.

That's normal.

The point isn't that a serious SaaS should never have infrastructure costs.

The point is that infrastructure costs shouldn't have to be the first barrier between an idea and its first working version.

Build the product.

Validate the idea.

Move to paid infrastructure when your usage actually requires it.

Why Next.js?

Next.js was another deliberate choice.

SaaS applications benefit from a framework that provides application routing, server-side capabilities, React integration, and a clear project structure.

SaaSStinger Lite uses:

Next.js 16
React 19
TypeScript
Tailwind CSS
shadcn/ui
pnpm

I wanted the stack to be modern without being unnecessarily exotic.

A starter kit is only valuable when developers can understand and modify it.

If the foundation is so unusual that the developer has to learn the foundation before they can use it, we've created another problem.

Next.js provides a familiar environment for developers already working in the React ecosystem while giving the project a strong structure for building production applications.

Workspace membership and invitations

Team-based SaaS applications eventually need invitations.

It sounds simple:

Send an invitation to another user.

But there are several questions hiding behind that feature.

What workspace are they being invited to?

Who is allowed to send invitations?

What role will they receive?

How is the invitation identified?

How does the invited user accept it?

What happens if the invitation expires?

What happens if the user already belongs to the workspace?

These are exactly the kinds of details developers end up solving repeatedly.

SaaSStinger Lite includes workspace membership and invitation infrastructure as part of the foundation so developers don't need to design the entire system before building the rest of their product.

Secure Firestore architecture

Once you have workspaces, the database rules need to understand membership.

A conceptual access flow looks like:

Authenticated user
       ↓
Workspace membership
       ↓
Role / authorization
       ↓
Permitted operation
       ↓
Firestore data

The important part isn't simply having Firestore rules.

It's ensuring that those rules reflect the application's actual authorization model.

If the frontend thinks a user belongs to Workspace A while the database accidentally allows access to Workspace B, you have an architectural problem.

SaaSStinger Lite treats authentication, membership, authorization, and Firestore security as connected parts of the foundation.

Audit logs

Another feature that's easy to postpone is auditing.

You can get surprisingly far without it.

Then something goes wrong.

A workspace member changes a setting.

Someone removes a user.

A configuration changes.

An important action occurs.

Now someone asks:

What happened?

Without an audit trail, you're left reconstructing events from whatever logs happen to exist.

SaaSStinger Lite includes audit logging as a foundation for tracking important workspace activity.

It's not intended to be a universal compliance system.

Instead, it's a starting point developers can extend with the events that matter to their own applications.

Usage tracking

Usage tracking follows a similar pattern.

Different SaaS products measure different things.

One product might track projects.

Another might track API calls.

Another might track storage.

Another might track seats.

SaaSStinger Lite provides a usage-tracking foundation that developers can adapt to their own product.

Again, the goal isn't to predict every possible SaaS business model.

The goal is to avoid starting with nothing.

This isn't a UI template

There are plenty of ways to get a beautiful SaaS dashboard on screen quickly.

That's not what I wanted SaaSStinger Lite to be.

The value isn't primarily the dashboard styling or individual UI components.

The value is the infrastructure underneath the application.

If you're looking for a blank project where you can invent your own architecture from scratch, SaaSStinger Lite probably isn't the right tool.

If you're looking for a no-code builder, it isn't that either.

And if you're only looking for a collection of landing-page components, there are better products for that.

SaaSStinger Lite is for developers who want a structured SaaS foundation that they can build on.

Who is SaaSStinger Lite for?

SaaSStinger Lite is primarily designed for developers and teams who already know what they want to build but don't want to repeatedly solve the same infrastructure problems.

That includes:

SaaS founders

You have a product idea and want to spend your time validating the product rather than repeatedly implementing authentication and authorization.

Indie hackers

You're building alone and need to move quickly without cutting corners on the foundation.

Next.js developers

You already know the React and Next.js ecosystem and want a more complete SaaS starting point.

Freelancers and agencies

You repeatedly build SaaS-like applications for clients and don't want to start the foundational architecture from zero each time.

Startup teams

You want a structured starting point that gives the team common architectural patterns from the beginning.

What developers get

SaaSStinger Lite includes a foundation covering:

Authentication
User profiles
Multi-workspace architecture
Workspace memberships
OWNER / ADMIN / MEMBER roles
RBAC
Invitations
Audit logs
Usage tracking
Workspace settings
Dashboard
Profile settings
Secure Firestore rules
Production documentation

It is built to be extended rather than treated as a finished SaaS product.

Your product is still your product.

SaaSStinger Lite simply removes some of the repetitive work required to get there.

What I learned building it

The biggest lesson from building SaaSStinger Lite was that the difficult part of a SaaS starter isn't adding more features.

It's making the relationships between the features make sense.

Authentication affects membership.

Membership affects authorization.

Authorization affects Firestore rules.

Workspaces affect nearly everything.

Invitations need to understand membership.

Roles need to be consistent with authorization.

Audit logs need meaningful events.

Usage tracking needs to fit the workspace model.

When these pieces are designed independently, they can work individually while still producing a fragile system.

The real work was making them fit together as one foundation.

That's what I wanted to package.

Who should use it—and who shouldn't?

SaaSStinger Lite is a good fit if you:

Know how to work with Next.js and React
Want to build a SaaS product
Need authentication and authorization
Need workspace/team functionality
Want a Firebase-based backend
Want to start within the Firebase Spark Plan
Prefer extending an existing architecture over building everything from zero

It may not be the right choice if you:

Want a no-code platform
Want a completely blank project
Need a backend other than Firebase
Want a framework-agnostic starter
Don't want architectural opinions
Are looking only for UI components

Being clear about this matters.

A useful developer tool doesn't need to be for everyone.

It needs to solve a specific problem well.

Why I built it

SaaStinger Lite came from a simple frustration:

I didn't want to solve the same SaaS problems again.

I wanted to get from:

"I have an idea."

to:

"I have a working SaaS product."

without spending the first part of the project rebuilding the same infrastructure every time.

So I built the starting point I wished I had.

Now I'm making it available to other developers doing the same thing.

The launch

SaaSStinger Lite is launching at $129 USD as a one-time purchase.

The goal of the launch isn't only to sell the starter.

I also want to hear from developers who are building SaaS products and understand where the real friction still exists.

Which part of SaaS infrastructure takes you the longest to build?

Authentication?

Authorization?

Multi-tenancy?

Database security?

Billing?

Team management?

Or something completely different?

That's the conversation I'm interested in having.

Because the best developer tools aren't built around a list of features.

They're built around understanding where developers are losing time.

And SaaSStinger Lite exists because I got tired of losing that time myself.

Build the product. Don't rebuild the foundation.

Learn more about SaaSStinger Lite:

https://saasstinger-website.vercel.app/

DEV Community: Femi Jazaniah Eguen