🔥 Engineer SaaS systems that scale and stay correct as they grow
Build SaaS Apps in days or weeks — not months. A complete SaaS framework that gives you speed and a foundation you won't outgrow.
Auth, data, search, files, sync, time-series, and dev tools - pre wired, production-ready and fully customizable in Typescript.
Start building - no credit card required.
🔥Leverage the parts that shouldn’t be rebuilt. Control the parts that matter.
Why teams choose SaasEasy
Most SaaS projects slow down because teams spend months rebuilding the same systems: auth, sync, search, files, metrics, debugging. SaaSEasy standardizes those pieces so you can: Move faster early, stay flexible later and understand your system as it grows
You’re not giving up control — you’re choosing leverage. What you get out of the box:
Launch Fast with with a real working app, not a demo.
Auth, users, roles, billing & subscriptions already wired.
Search, audit logs & file storage built from day one.
Time-series & easy charting for usage and operation signals.
Automatic data access & sync across backend, web and mobile.
Built in dev tools that help you understand what's happening
No boilerplate. No stitched-together services. No hidden magic.
Use the tools you already know.
React - React Native/Expo - Node.js - Typescript - SQL
You write normal application code. SaasEasy handles the infrastructure glue around it.
🔥 Less friction. More progress.
Remove the pain points that slow real SaaS development
Most SaaS projects don’t struggle because of features — they struggle because of infrastructure. SaaSEasy standardizes the systems every SaaS needs so you can move faster without losing control.
Systems that evolve without structure
The pain
As features grow, ad-hoc patterns turn into fragile conventions. What started as “just ship it” becomes hard to change without breaking things.
How SaaSEasy helps
SaaSEasy enforces consistent structure from day one — around data access, events, auth, and side effects — so growth doesn’t turn into chaos.
Business logic scattered across layers
The pain
Rules split between backend endpoints, frontend state, background jobs, and cron scripts are hard to reason about and easy to break.
How SaaSEasy helps
SaaSEasy centralizes decisions around domain models and repositories, so behavior stays correct and predictable as the system grows.
Endless API and integration plumbing
The pain
Every new resource means more REST or GraphQL endpoints, more client wiring, more validation, and more places for bugs to creep in.
How SaaSEasy helps
Server, web, and mobile code all use the same typed interfaces. APIs are standardized, not reinvented, so you stop writing plumbing and start writing logic.
Debugging by guesswork
The pain
Logs without context, metrics without meaning, and bugs you can’t reproduce slow teams to a crawl.
How SaaSEasy helps
Built-in observability ties requests, data changes, events, and side effects together, so you can see what happened — and why — without guessing.
“Temporary” infrastructure that becomes permanent
The pain
Quick integrations turn into long-term dependencies with no clear ownership, documentation, or consistency.
How SaaSEasy helps
Core systems like auth, search, files, metrics, and audit logs are standardized early, so you don’t accumulate hidden architectural debt.
Multiple data models for the same thing
The pain
One model in the database, another in the API, another in the frontend, and another in mobile — all slowly drifting apart.
How SaaSEasy helps
Define your domain once and use it everywhere: backend services, web clients, and mobile apps all share the same model and rules.
Rewriting instead of extending
The pain
Many frameworks are great until requirements change — then you’re forced to rewrite or work around the tool itself.
How SaaSEasy helps
SaaSEasy is designed to evolve. You extend it with normal application code instead of throwing it away when the product matures.
Shipping fast early, then slowing down
The pain
Initial velocity is easy. Staying fast as complexity grows is hard.
How SaaSEasy helps
By making complexity deliberate, consistent, and visible, SaaSEasy helps teams stay fast — not just at launch, but over the lifetime of the product.
The Core Technologies You’ll Build With
Familiar tools. Clear boundaries. No surprises.SaaSEasy doesn’t invent a new stack. It standardizes how proven tools work together to build SaaS systems. You write TypeScript everywhere, using technologies you likely already know.
The lists below show the core technologies SaaSEasy is built on. They’re not exhaustive — but they represent what you’ll use day to day.
Backend Stack
You build your backend using standard Node.js patterns, with SaaSEasy providing structure and glue.
Typescript
Node.js + Express
SQL databaes (MySQL today, Postres)
EZRepo's (SQL Repo built on TypeORM ) with explicit decorators/typesafe configs for:
multi-tenancy isolation, search indexing, file relations, API visibility and access rules, and more...
Stripe for billing and subscriptions
Optional, integrated services
These are optional — but deeply integrated when used:
Search (Meilisearch today, Typesense & OpenSearch planned)
File storage (S3-compatible: AWS, DigitalOcean, Wasabi, etc.)
SaaSEasy wires these services together through consistent abstractions so they behave like part of one system — not separate integrations.
*Workflow Repos coming in version 2.
Frontend Web Stack
Frontend code is standard React — not a proprietary runtime.
React
Material UI
Typescript
Shared SaaSEasy data access APIs:
Same repositories used on backend and frontend
Automatic data sync availabe where appropriate
Typed hooks for auth, roles, permissions, and subscriptions
You write normal React components.
SaaSEasy removes boilerplate around data access, forms, and common SaaS workflows.
🔥Opinionated where it matters. Invisible everywhere else.
What SaasEasy Adds (On Purpose)
SaaSEasy introduces its own primitives only where consistency matters:
- Standardized repositories for data access
- Resource events for sync and side effects
- Declarative search, files, time-series, and audit logging
- Built-in dev tooling for tracing and debugging
- These aren’t shortcuts — they’re guardrails.
They exist so:
- Systems behave consistently
- Debugging is possible
- Growth doesn’t require rewrites
What This Means for You
- You’re not learning a new language
- You’re not locked into a proprietary runtime
- You’re not guessing how things work under the hood
- You are choosing a framework that provides real leverage
- You can always go lower-level when needed. Most of the time, you won’t need to.
Build Your SaaS Apps in clear, deliberate steps
SaaSEasy helps you start with a solid foundation and add real features incrementally — without blocking you from writing custom code or accessing the underlying stack.
You’re not locked into a workflow.
You’re given a sensible default.
Create a working foundation
Generate a backend, web frontend, or mobile app in minutes.
npx saaseasy new my-app
You start with:
- A running app
- Backend and frontend wired together
- Local dev environment ready
- Core infrastructure already in place
This is a starting point — not a black box.
Model your domain once, use it everywhere
Define your data using TypeORM and SaaSEasy decorators to describe:
- Fields and relationships
- Access rules
- File associations
- Search indexing
- Multi-tenancy
That same model becomes:
- Database schema
- Backend data access
- Typed frontend APIs
No duplicate definitions.
No hand-written API plumbing.
Authentication and user management are already handled
User signup, login, roles, permissions, and invitations are built in and enforced consistently.
You decide:
- Who can do what
- Which actions require which roles
You don’t rebuild auth — you configure and extend it where needed.
Add payments and subscriptions
Enable subscriptions or one-time payments by configuring SaaSEasy’s billing modules.
This lets you:
- Launch monetization early
- Avoid brittle billing code
- Change plans and pricing later without reworking your app
Payments become part of your system — not a fragile integration.
Build data-driven UIs faster (web and mobile)
Use optional SaaSEasy UI helpers:
- Resource forms
- Smart form fields inside resource forms, react hook forms or standalone.
- Tables
- Typed data hooks
They sit on top of normal React and React Native code.
Use them where they help. Skip them where they don’t.
Extend with normal application code
When you need custom behavior:
- Write Node.js / TypeScript
- Add Express routes, either SaasEasy wired & aware or plain express if you need to.
- Build React components
- Implement domain-specific logic
SaaSEasy doesn’t replace your code — it removes the repetitive infrastructure around it.
Launch, iterate, and grow
Deploy your app and keep building as usage grows.
Search, audit logs, time-series metrics, file handling, and dev tools are already there — so growth doesn’t force a rewrite.
Meet The Founder
Built by someone who got tired of rebuilding the same SaaS infrastructure
Hi — I’m Mike.
I’ve been building software for over two decades, across enterprise systems, developer tooling, and SaaS products. I spent more than 10 years at IBM Research & Development working on large-scale, event-driven systems and internal product platforms, and before and after that I’ve shipped full-stack software across Java, Node.js, TypeScript, React, and modern web and mobile stacks.
I launched my first SaaS product in the early 2000s — and like most developers who keep building SaaS, I eventually hit the same wall:
Every new app meant rebuilding the same foundations:
- authentication and user management
- permissions and authorization
- payments and subscriptions
- backend APIs and frontend data access
- file uploads and downloads
- search, metrics, and debugging
Individually, none of these are hard. Collectively, they’re where time disappears and systems quietly rot.
- I wanted the speed people associate with no-code tools, but without giving up:
- real code
- architectural control
- debuggability
- or the ability to grow beyond the first version
SaaSEasy is the result of that frustration.
It’s now in its third major iteration, shaped by real production use, failures, and lessons learned the hard way. The goal was never to hide complexity — it was to standardize it, so building SaaS stops feeling like starting from scratch every time.
SaaSEasy is the framework I wish I had years ago:
- opinionated where consistency matters
- flexible where customization matters
- explicit about tradeoffs
- and honest about what it’s doing under the hood
I built it first to solve my own problems. Now I’m sharing it so other developers don’t have to repeat the same work.
If you care about building SaaS systems that last — and understanding how they work — you’re in the right place.
Background
M.S. in Computer Science
Former Division I-AA scholarship athlete
No more building CRUD/Query REST API's!
Expose Data & API's To Frontend Apps Fast
Model your data classes using an ORM (TypeORM supported currently)
Access your data through EZ Repo api's on the client just like you would do on the server.
let user: User | undefined = Repos.getRepo(User).findById(1);
Behind the scenes, frontend Repo's are calling automatically available REST API's for your all your model classes.
You can add File(s) to your data classes and also mark which data is server only, frontend readonly as well.
Provide Full Text Search Support
Auto Search Indexing In ElasticSearch
Have your Resource data auto indexed in ElasticSearch by providing a few annotations to your data classes.
Your Indexes will be created, updated and deleted automatically as your data changes, no matter where the changes come from, backend code, api calls or direct DB modification.
Local Filesystem or S3 File Support
Add Files To Your Data Easily
Add file relations to your data classes then use easy API's and components to quickly manage files.
Access your data through the Files api on server and frontend.
//server
Files.getFileAsBuffer(User, "resume", userId);
//client
Files.uploadFile(User, "resume", userId, theFile);
EZFileUpload component.
EZFileDownload component.
Behind the scenes, frontend Files api is calling automatically available REST API's.
You can set restrictions on your file data as well, such as file size limit and more.
No 3rd Party Hassles/Limitations
Authentication Out Of The Box
Don't write a single line of code to handle authentication.
Password Login & Account Management
Login, Signup, Logout, Forgot Password, Change Password, Login Codes, Cancel/Delete Account, Multi user invitations
2 Factor Authentication
Auth Apps, Security Keys, Recovery Codes, Backup Emails, Login Sessions
API Key Authentication
Give access to other backend code or your end users access to your api's.
Plugin In Your Own Provider
Create your own authentication provider if needed
Role/Permission based Authorization
Quickly protect access to resource data and API's
Allow access by role/permissions. Permission definitions are typesafe and allow dropdown selection of resources and properties to protect.
You can use EZRoles api to manage user roles, EZPermissions.hasPermissions() in any custom code or @Authorization() decorator to protect @Route()'s!
*all data is automatically isolated at the tenant level. This is for fine grained role based data access control.
Keep Your Users Data Safe!
Auto Tenant Data Isolation w/ 1 Decorator
SaasEasy automatically keeps tenant data isolated. All you need to do is add 1 annotation to any of your data classes that provide per tenant data.
No Cross Tenant Data Access Allowed
Keep your users data safe from prying eyes and hackers.
Need Global Data?
Don't Include The @TenantId() on data classes that need to be global data
Auto Managed
On Create/Update & Queries You Make Through EZ Repo's
Fully Functional w/ A Little Configuration
React Web & Mobile Expo Apps Fast
Fully Coded Templates
Templates fully functional with a little configuration and ready for you to start building your app.
Web: React, Material UI, Typescript
Built with the most popular Javascript libraries & technologies.
Mobile: React Native, Expo, React Native Paper, Typescript
Built with the most popular Javascript libraries & technologies.
Layout, Navigation, Authentication, Stripe & Fully Themed
All ready to go out of the box with just a little configuration.
EZ Access to backend data & Auto Sync!
No more write REST API's or code to call them. Use Repo & Files api's just like you would on the backend!
Prebuilt Subscriptions & Product Purchases Support
Pricing Tables
Just configure your Stripe subscriptions and pricing tables are ready.
useSubscription() & useProductPurchases() Hooks
Get access to subscription & product purchases data.
useStripeCheckout() Hook
While you can can use the built in Pricing Tables & Product displays, you can also add/remove things from cart from anywhere in your app too.
Subscriptions & Product Checkout
Like Stripe Checkout, But Built In & Fully Themed!
Subscription Checkout
New subscriptions, change subscriptions, subscription prorations, cancel & quantity
Product Purchases Supported
You can sell 1 time product purchases in your apps too.
Stripe Web Events Fully Integrated & Handled
All subscription & product purchase Stripe Web Events have already been handled for you.
useStripeCheckout() Hook
You can interact with your built in cart from anywhere in your app using the useStripeCheckout() hook.
Custom Routes & EZ API's
Create custom routes easily. Custom routes automatically get the full EZ Hander chain, including CORS, Authentication, Authorization, Cookies and more.
Use EZ API's to build your routes quicker
Use the many built in EZ API's that allow you to build your custom routes with ease.
Add Custom Express Middleware To Your Routes
If you need to do something specific on your route pre-handling you can easily add handlers to the chain.
Easily Create Custom File Upload/Download Routes Too
Sometimes you need to have custom file upload/download routes beyond the auto file relations on your resources.
Override Built In Auto Resource API Actions
SaasEasy makes auto resource API's available which are called under the hood from the client side when using Repo & Files api's. If you need to provide some custom code, you can do that.
Override Built In Auto Resoruce CRUD++ Routes
Use our EZ Form Field components to quickly build resource based forms.
Consider using ResourceEvents to run code before creating overrides.
ResourceEvents can be used to run code when resource events occur, instead of overriding User CREATE, you could subscribe to the event and take some action.
Resource Events - Get Notified & Run Custom Code
You can subscripe to ResourceEvents on the server & client side to be notified and run code when resource events occur.
Resource Events Trigger No Matter How The Data Changed
You will receive Resource Events whenever resources are create/updated/deleted and more whether changes occured via API, backend code or directly in the database.
Subscribe to Resource Events on Server or Client side.
Auto sync data is available for client side, so you only need to use this to run other code when events occur.
Build Forms With Less Code
EZ Resource Forms
EZ Form Fields
Use our EZ Form Field components to quickly build resource based forms.
Create/Update/Delete Resources Auto Handled
You just focus on laying out your form.
Override Field Output Values If Needed
Sometimes your form representation of the data is different from your resource data. Just provide an outputValue() function for that field.
beforeCreate, afterCreate, onDeleted.... callbacks.
Form lifecycle callbacks available to run any extra code you need to.
Built On Top Of React Hook Form
Since Resource Forms are built on top of React Hook Form you can use those hooks as well if you need to.
EZ Smart Form Fields Can Be Used Anywhere
Our EZ Form fields can be used anywhere you want to use them, they detect what context they are being used in and will alert you if being used incorrectly for that context.
Use in EZ Resource Forms
Use them to quickly build auto CRUD Resource Forms without having to write code to set backend data.
Use in plain React Hook Forms
You can also use the fields in a plain React Hook Form if you want.
Use standalone outside of any form
Don't need a form, just need a field to grab some data from the user, do that too!
Developing & Hosting SaasEasy Apps
MySQL or Postgres
You'll need version 8+ of Mysql for now, Postgres support coming later.
NodeJS version 20 or greater.
SaasEasy is also built using Typescript.
Optional: Meilisearch.
You only need Meilisearch if you use Auto Search Indexing.
Recommended IDE: Visual Studio Code
Our documentation and code generation plugins will be tailored and built for VSC
S3 Hosting For File(s) Support
If your data models will include file(s), then you'll need S3 file hosting.
Such as: AWS, Digital Ocean Spaces, Wasabi, etc..
Hosting SaasEasy Backend/Web Frontends
SaasEasy comes out of the box based on Vite.
We recommend proxying your backend app and frontend node app with Nginx.
Then configure PM2 to start your apps, and restart if they crash.
How SaaSEasy scales (without pretending it’s magic)
SaaSEasy doesn’t invent new scaling techniques. It’s designed to sit cleanly on top of proven, well-understood infrastructure and stay out of the way as you scale.
Scaling comes from the underlying systems — SaaSEasy’s job is to not prevent you from using them correctly.
Relational databases as the primary system of record
SaaSEasy is built around relational databases as the system of record.
Primary targets are MySQL and PostgreSQL.
You scale them using standard, production-proven approaches:
- Vertical scaling and read replicas
- Native high-availability and clustering setups
- Explicit application-level partitioning
- Distributed databases when required (e.g. Vitess, Citus)
SaaSEasy does not hide or replace your database. There is no proprietary data layer, no ORM-level sharding, and no magic routing.
You scale your database the same way you would in any serious production system.
Search scales independently (when you enable it)
If you enable automatic search indexing, SaaSEasy integrates with a dedicated search engine.
Meilisearch (supported today)
Typesense / OpenSearch (planned)
Search is:
- Event-driven
- Decoupled from core reads and writes
- Horizontally scalable on commodity hardware
If you don’t need search, it doesn’t run. If you do, it scales independently of your database.
Connection-Aware Application Servers (No Sticky Sessions)
SaaSEasy application servers do not require sticky sessions or shared in-memory state. Servers may hold ephemeral, connection-scoped state (for example, active WebSocket connections used for auto-sync), but no durable or correctness-critical state lives on the application node.
This means:
- You can run multiple identical server instances
- You can scale horizontally behind standard load balancers
- You do not need sticky sessions or session affinity
- WebSocket connections can terminate on any node
- Nodes can be restarted or replaced without coordination
All authoritative state, synchronization logic, and ordering guarantees live in external systems (databases, event streams, CDC pipelines), not in server memory.
There is no proprietary runtime, no cluster membership service, and no coordination layer required.
Standard tools like NGINX, HAProxy, or managed cloud load balancers work out of the box.
File storage scales with your storage provider
File handling in SaaSEasy is based on S3-compatible object storage.
That includes:
- AWS S3
- DigitalOcean Spaces
- Wasabi
- Other S3-compatible providers
Scaling characteristics depend on your chosen provider — SaaSEasy simply integrates with it in a consistent, predictable way.
What SaaSEasy does not claim
SaaSEasy does not claim to:
- Automatically shard your database
- Eliminate the need for architectural decisions
- Magically scale without understanding your workload
Those claims usually don’t survive contact with reality.
If you ever reach true Google / Netflix / Amazon scale — first, congratulations — and second, at that point you’ll be building custom infrastructure anyway, funded by millions in revenue.
What SaaSEasy does provide
- Clear system boundaries
- Connection-Aware Application Servers (No Sticky Sessions)
- Event-driven side effects
- Infrastructure that scales independently
- No hidden bottlenecks introduced by the framework
In other words:
SaaSEasy scales because the systems underneath it scale — and it doesn’t get in the way.
SaaSEasy doesn’t promise effortless scale. It gives you a sane, scalable starting point that won’t force a rewrite later.
Frequently AskedQuestions
Yes, absolutely! Our license doesn't limit charging end users (tenants/users) on a SaaS App.
Simple, per developer pricing
SaaSEasy is licensed per developer, per year. You can build unlimited applications. You own everything you build. As long as your subscription is active, you receive updates. If you cancel, you retain access to the last version you were licensed for. No usage limits. No per-app fees. No hidden tiers.
$ 197/year
Bootstrapper License
If you're an idie developer or part of a startup without funding, you can enjoy SaasEasy (EZ) at a discount!
- Access for 1 developer.
- Unlimited app creation.
- Full access to all SaaSEasy features
- Web, mobile, and backend support
🔥 Founding Developer Pricing (limited) - $97/year
- Available to first 1,000 developers.
- Same access as the Bootsrapper License
- Your price stays locked as long as your subscription remains active
- Cancel and the grandfathered rate is lost.
- When it's gone, it's gone.
$ 497/year
Standard License
- Access for 1 developer.
- Unlimited app creation.
- Full access to al features.
- Production use at scale.
- Same framework. Same capabilities.
$ 1,297/year
Agency License
If you want to build & sell applications to clients you can do that with an agency license.
- Access for 1 developer.
- Unlimited app creation.
- Access to all features.
- White labeling available.
*Bootstrapper/Standard License: Selling/exiting an app/business one day is ok, as long as you weren't using our software to operate as an agency without an agency license.
*Restrictions on any license: You can't use our software to create app builders, site builders, development tools or frameworks.
Launching Soon — Founding Developer Pricing
SaaSEasy has been used in production for real applications for quite a while. We’re now putting the final pieces in place to make it ready for self-serve adoption.
We’re opening early signup for developers who want in from day one.
Founding Developer Offer
- Regular pricing: $197 / year
- Founding developer pricing (first 1,000 developers): $97 / year
- Grandfathered forever — your price never increases
This is not a beta gimmick. This is for engineers who want to build real SaaS systems on a foundation that’s already proven.
Sign up to get early access and lock in founding pricing.
Pricing FAQ
A license is required for each developer who actively uses SaaSEasy to build or maintain applications. If two developers are working on the same codebase, each needs a license. If one developer builds multiple applications, a single license covers all of them.
