What it does

TYPUS is a full-stack TypeScript SaaS framework -- a self-hosted SaaS boilerplate that gives you authentication, admin panel, and a complete backend from day one. Every time you start a new SaaS project, you rebuild the same things: user authentication, role-based permissions, file uploads, email notifications, background jobs. By the time the foundation is ready, weeks have passed and you have not written a single line of business logic.

TYPUS is that foundation, already built. Clone the repo, start Docker, and you have a working application with JWT authentication, OAuth, two-factor auth, an admin panel with 50+ Vue 3 components, CASL-based permissions, file storage, email system, WebSocket real-time events, and background job queues. All in TypeScript, all self-hosted, zero vendor lock-in.

The core idea is a DSL model system. You define your data model once in a declarative schema, and TYPUS generates the REST API, TypeScript types, database migrations, validation rules, and admin panel CRUD interface. Change the model, everything updates. No hand-writing boilerplate for each entity.

Built as a plugin architecture, so you extend without touching core. CRM, newsletter, waitlist, workflow. each is a plugin that drops in cleanly. Write your own or use the included ones.

Results & Impact

1,349 commits over 12 months of solo development, from first line of code to production-ready framework with a live demo, documentation website, public GitHub repository, and a book on Amazon documenting the entire journey.

The entire framework was built by one developer, starting manually in November 2024 and progressively incorporating AI-assisted development as tools improved through 2025. A demonstration that one person with the right tools can build infrastructure that traditionally requires a team.

Ships as a two-container Docker setup (app + MySQL) that runs on any machine with Docker installed. Zero-config localhost mode means clone-and-run with no external dependencies.

Key Features

• DSL Model System. Define a data model once. Get REST API, TypeScript types, database schema, validation, and admin CRUD automatically generated. Schema-as-code.
• Authentication. JWT, OAuth, sessions, two-factor authentication with TOTP. Magic links. Everything needed for production auth, no third-party service required.
• Plugin Architecture. Extend without touching core. CRM, newsletter, waitlist, workflow plugins included. Write your own with backend + frontend modules that drop in cleanly.
• 50+ Vue Components. Admin panel with tables, forms, modals, file managers, rich text editors, charts. All TypeScript, all themed, all ready to use.
• Background Jobs. Queue system for emails, notifications, data processing. Database-backed by default (no Redis required), Redis optional for scale.
• Self-Hosted. Two Docker containers: app + MySQL. Runs on any VPS, cloud instance, or laptop. Three deployment profiles: local, dev, production. No vendor lock-in.
• Real-Time. WebSocket events for live updates. Notifications, data changes, user presence. Works without Redis for small deployments.
• Permissions (CASL). Role-based access control with CASL. Define abilities per role, enforce on both frontend (UI visibility) and backend (API access). Granular and composable.

How it works

TYPUS runs as a single application container managed by supervisord, with nginx handling HTTP, Express running the backend API, and Vue 3 serving the frontend. A separate MySQL container stores all data.

The backend is organized into modules: auth, cms, crm, email, newsletter, storage, system, and more. Each module registers its own routes, middleware, and database models. The frontend mirrors this structure with Vue modules that map to backend modules.

The DSL engine sits at the center. You write a model definition that describes fields, types, relationships, and validation rules. The engine reads this and generates Prisma schema, Express API routes, TypeScript interfaces, and Vue admin components. When you change the model, you run one command and everything regenerates.

Stack: TypeScript end-to-end. Node.js + Express backend, Vue 3 + Vite frontend, Prisma ORM, MySQL database. Docker for deployment with supervisord managing processes inside the container.

Quick Start

Running locally takes under 5 minutes. Docker required.

# Clone the repository
git clone https://github.com/typus-dev/typus.git
cd typus

# Start (zero-config localhost mode)
docker compose up -d --build

# Open in browser
# http://localhost:3000
# Login: admin@localhost / admin12345

This starts two containers: the app and MySQL. The database is initialized automatically on first run with seed data and an admin account. No external database, no environment variables, no configuration file needed for local development.

Use Cases

For solo developers. Launch a SaaS MVP without rebuilding auth. Skip the first month of boilerplate. Authentication, admin panel, permissions, file storage, and email are already built. Start with business logic on day one.

For small teams. Internal tools with proper access control. Build internal dashboards, CRMs, or content management systems. Role-based permissions ensure each team member sees only what they should. Plugin architecture keeps modules independent.

For self-hosting advocates. Own your infrastructure completely. No third-party auth service, no managed database, no cloud lock-in. Two Docker containers on any server you control. MIT license, full source access.

Lessons Learned

AI changed the equation. I started TYPUS in November 2024 writing everything by hand. By mid-2025, AI-assisted development was handling significant portions of the work. By late 2025, it became clear that AI tools could generate the same boilerplate that TYPUS was designed to eliminate. The framework solved a real problem, but the problem was shrinking. Sometimes the right decision is to recognize when the landscape has shifted.

DSL is powerful but demanding. The model DSL that generates APIs, types, and admin interfaces is the most powerful feature and the most complex to maintain. Every edge case in data modeling (polymorphic relationships, computed fields, nested validation) becomes a DSL engine problem. The productivity gain is real, but the abstraction has a maintenance cost that grows with every feature.

One developer, 1,349 commits. Building a full-stack framework solo means making every architectural decision yourself, with no one to review the tradeoffs. The upside is speed and consistency. The downside is blind spots. The plugin architecture was the decision that aged best: it forced separation of concerns even when I was the only person writing code, which kept the codebase navigable at scale.

FAQ

What is TYPUS?

A production-ready TypeScript foundation for building self-hosted SaaS applications. It provides authentication, admin panel, plugin architecture, auto-generated CRUD APIs, and a database DSL out of the box. You add business logic, everything else is already built.

Why build a framework instead of using Next.js or Nuxt?

Next.js and Nuxt are rendering frameworks. TYPUS is a business application framework. It includes things that rendering frameworks do not: user management with roles and permissions, background job queues, file storage, email and notification systems, CRM and newsletter plugins. The goal was to have a complete SaaS backend on day one, not to assemble it from 20 separate packages.

Why is the project paused?

By late 2025, AI-assisted development made it possible to build the same kind of application faster and simpler without a heavyweight framework. The problem TYPUS solved, reducing boilerplate and setup time for SaaS projects, is increasingly solved by AI coding tools. The project remains open source and functional, but active development has stopped.

Can I use TYPUS for my project?

Yes. It is MIT licensed, self-hosted, and runs in Docker with two containers. Clone the repo, run docker compose up, and you have a working SaaS application at localhost:3000 with admin panel, authentication, and all core features. No external services required.

What is the DSL model system?

Instead of writing database migrations, API endpoints, TypeScript types, and validation rules separately, you define a model once in a declarative schema. TYPUS generates the REST API, TypeScript interfaces, database schema, and admin panel CRUD interface from that single definition. Change the model, everything updates.