No. The core is profile-scoped. Add organization, team, or multi-tenant behavior as a module in the product you build from it.

Production-ready SaaS foundation

Build your SaaS on a foundation made to ship.

Q: Can I change the frontend stack?

The frontends are standard React + TypeScript projects. You can adapt or replace them, though you get the most value keeping the structure.

Q: Does it support multiple languages?

Yes. Internationalization is included: locale routing, translation files and language selectors across the frontends.

Q: Is authentication already implemented?

Yes. Authentication flows with Supabase, session handling and protected routes are implemented across the web app and admin panel.

Q: Which payment providers are integrated?

Stripe and Paddle, both wired end to end: checkout, signed webhooks and entitlements. You configure credentials in the admin panel and set a country-to-provider rule: typically Stripe at home and Paddle as merchant of record abroad, so VAT and sales tax are handled for you.

Q: Can agencies use it for client projects?

Yes, under the Agency License. Each license tier defines how many products and developers are covered.

Q: Does it include deployment configuration?

Yes. Vercel-ready frontends and a containerized API. Deploy to whichever host you prefer.

Q: Can I customize the branding?

Yes. Branding is centralized in config/branding.json: name, colors and locale flow through the apps.

Q: Is the backend included?

Yes. A .NET 10 API with EF Core, PostgreSQL migrations and versioned endpoints ships with the template.

A production-ready SaaS foundation with authentication, billing, admin tools, a React web app, .NET APIs, testing and deployment workflows already structured.

Get CastorStack Explore the Architecture

React + TypeScript.NET 10 APIi18n includedCI/CD ready

Marketing SitePublic pages, pricing and SEO

React Web AppCustomer area with auth and billing

.NET APIProducts, plans, features and payments

Database · Auth · PaymentsPostgreSQL, Supabase, Stripe + Paddle

Admin PanelOperate products, plans and PSPs

Why a foundation

Stop rebuilding the same SaaS foundation.

Start with the parts that make your product unique. The rest is already structured.

Starting from scratch

Design, build and test authentication
Design, build and test session handling
Design, build and test admin structure
Design, build and test product and pricing models
Design, build and test global payments with two providers
Design, build and test internationalization
Design, build and test tests
Design, build and test ci/cd
Design, build and test deployment structure
Design, build and test documentation

Starting with CastorStack

Authentication: already structured
Session handling: already structured
Admin structure: already structured
Product and pricing models: already structured
Global payments with two providers: already structured
Internationalization: already structured
Tests: already structured
CI/CD: already structured
Deployment structure: already structured
Documentation: already structured

What's inside

Every layer of a real SaaS, already in place.

Three frontends, one API and the operational plumbing between them.

Marketing Site

Public site with pricing, SEO structure and i18n, connected to the product catalog.

Included

Customer Web App

Authenticated customer area: dashboard, plan, usage and billing foundation.

Included

Admin Panel

Operate products, plans, features, users, subscriptions and PSPs.

Included

.NET API

.NET 10 API with EF Core, PostgreSQL and versioned endpoints.

Included

Authentication

Supabase-backed auth with sessions and protected routes across apps.

Included

Product Management

Products, plans and catalog managed from the admin panel.

Included

Pricing & Features

Plans, feature flags and plan-feature bindings ready to model your offer.

Included

Payment Providers

Stripe and Paddle wired end to end: checkout, signed webhooks and entitlements, with checkout binding per plan.

Included

Internationalization

Locale routing, translation files and language selectors in every frontend.

Included

Automated Testing

Vitest unit tests on the frontends, xUnit tests on the API and Playwright end-to-end suites.

Included

Deployment

Vercel-ready frontends and a containerized API you can deploy anywhere.

Included

Centralized Configuration

Branding, product, pricing and features driven by config files.

Extensible

Global billing

Sell worldwide without a local entity in every market.

Domestic customers are charged through Stripe. Everyone else goes through Paddle as merchant of record, so VAT and sales tax are handled for you.

Country-to-provider routing rule, configured in the admin panel
Signed webhooks from both providers unlock the same entitlements
One checkout endpoint: the API resolves which provider to use

Buyer's countryConfirmed at checkout

Routing ruleDomestic, international, fallback

StripeYour domestic account

PaddleMerchant of record

Webhook → accessEntitlement granted

Architecture

One monorepo. Clear boundaries.

Every app has a single responsibility, and shared concerns live in one place.

saas-core/

├─ apps/

│ ├─ marketing-site/ # Next.js

│ ├─ web-app/ # React + Vite

│ └─ admin-panel/ # React + Vite

├─ backend/api/ # .NET 10

├─ config/

│ ├─ branding.json

│ ├─ product.json

│ ├─ pricing.json

│ └─ features.json

├─ docs/

├─ e2e/

├─ scripts/

└─ shared/

apps/

Three frontends with the same design language: marketing, customer app and admin.

backend/api/

.NET 10 backend: products, plans, features, users, subscriptions and payment providers.

config/

branding.json, product.json, pricing.json and features.json drive the whole product.

shared/ · docs/ · scripts/

Conventions, documentation and automation shared by every project.

Explore the full architecture

Stack

A stack teams already know.

No exotic dependencies. Proven tools, typed end to end.

Frontend

ReactNext.jsViteTypeScriptReact Routeri18nextVitest

Backend

.NET 10C#EF CorePostgreSQLSupabase Auth

Quality & Infra

Playwright E2ESentryVercelMigrationsEnv Config

How it works

From download to deploy, without detours.

Branding, product, pricing and features are centralized configuration, not scattered constants.

Download the code

One monorepo with frontends, API, database and scripts.

Configure your brand

Set name, colors and locale in config/branding.json.

Define products and pricing

Model plans and features from the admin panel or config files.

Connect auth and payments

Plug in Supabase credentials and your Stripe and Paddle keys. The integrations are already built.

Build your unique experience

Spend your time on the product, not on the boilerplate.

Deploy

Ship to Vercel or any host you choose, with no lock-in.

config/branding.json

{
  "productName": "Your SaaS",
  "defaultLocale": "en-US",
  "currency": "USD"
}

Guided onboarding

A guided path from zero to your first payment

Your purchase includes a 15-step onboarding trail in English, Spanish, and Portuguese. It takes you from an unopened package to a deployed product taking real payments. Every step ends with a verifiable check, written to be executed with an AI coding agent.

Who it's for

Built for people who ship SaaS.

Different goals, same starting point.

Solo founders

Validate your idea with a real working product instead of a prototype.

SaaS developers

Skip the plumbing and work on the features that set your product apart.

Freelancers

Deliver client SaaS projects with a professional baseline from day one.

Software agencies

Standardize how your team starts every SaaS engagement.

Internal product teams

Launch internal tools with auth, admin and billing structure ready.

Serial builders

Reuse the same foundation across multiple products without re-learning it.

In detail

What the foundation covers.

Grouped by the areas that matter when you're shipping.

Monorepo structure

Shared conventions

Centralized configuration

Documentation

Authentication flows

Protected routes

Session management

Customer dashboard foundation

Responsive layouts

Admin authentication

Product management

Feature management

Payment provider configuration

Country-to-provider routing

Operational controls

Automated tests

Deployment structure

Environment separation

Internationalization

Language selector

Translation files

Locale-based experience

Merchant-of-record billing via Paddle

Monorepo structure

Shared conventions

Centralized configuration

Documentation

Preview

Three frontends, one visual language.

Same design system, different jobs.

Marketing Site

Sell the product: hero, pricing and SEO-ready pages.

Customer Web App

Simple, value-oriented area for the end customer.

Admin Panel

Dense, operational cockpit for the people running the SaaS.

Extensibility

Change configuration, not scattered code.

Product identity and commercial rules live in versioned config files.

config/product.json

{
  "productName": "Your SaaS",
  "defaultLocale": "en-US",
  "currency": "USD"
}

config/pricing.json

{
  "plans": [
    {
      "name": "Starter",
      "price": 29
    }
  ]
}

Illustrative examples: check the package for the exact configuration contracts.

Pricing

One foundation. Pick your license.

2 licenses, one codebase: authentication, global billing, admin tools and a .NET API, in code you own.

SaaS Core

Free

Plano gratuito

R$0 /monthComing soon

SaaS Core

Pro

Plano profissional

R$30 /monthComing soon

Licensing terms are summarized on the license page

FAQ

Frequently asked questions

Is CastorStack a no-code product?

No. It's a code-first foundation for developers: a monorepo with React frontends, a .NET API and configuration files you own and extend.

Can I change the frontend stack?

Does it support multiple languages?

Is authentication already implemented?

Which payment providers are integrated?

Is it multi-tenant?

Can agencies use it for client projects?

Does it include deployment configuration?

Can I customize the branding?

Is the backend included?

Your next SaaS should start with the product, not the boilerplate.

Get the codebase and spend your first week on what makes your product different.

Get CastorStack View Documentation