AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

saas-scaffolder

Use when starting a new SaaS app with auth, database, Stripe billing and a dashboard (Next.js App Router, TypeScript, Tailwind, shadcn/ui, Drizzle). Bootstraps it with project_bootstrapper.py.

Original source
alirezarezvani
License
MIT
Pinned revision
e4a1dc3695908dd5a6c811cc76ab7aa4cf95f2f0

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

This skill also requires local files or dependencies. Remote reading alone may not be enough.

Ask your assistant

Use Agentic Memory skills to read alirezarezvani--saas-scaffolder at revision e4a1dc3695908dd5a6c811cc76ab7aa4cf95f2f0, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 5

references/tech-stack-comparison.md

Technology Stack Comparison

Overview

Choosing the right technology stack is one of the most impactful early decisions for a SaaS product. This comparison covers the most popular options across frontend, backend, database, and caching layers, with decision criteria for each.

Frontend Frameworks

Next.js (React)

Strengths:

  • Largest ecosystem and community
  • Excellent developer tooling and documentation
  • Server-side rendering (SSR) and static generation (SSG) built in
  • Vercel deployment makes hosting trivial
  • App Router with React Server Components for optimal performance
  • Rich component library ecosystem (shadcn/ui, Radix, Chakra)

Weaknesses:

  • React learning curve (hooks, state management, rendering model)
  • Bundle size can grow without discipline
  • Vercel lock-in concerns for advanced features
  • Frequent major version changes

Best for: Most SaaS products, teams with React experience, SEO-important pages

Remix (React)

Strengths:

  • Web standards focused (forms, HTTP, progressive enhancement)
  • Excellent data loading patterns (loaders/actions)
  • Built-in error boundaries and optimistic UI
  • Works without JavaScript enabled
  • Strong TypeScript support
  • Deployable anywhere (not tied to specific platform)

Weaknesses:

  • Smaller ecosystem than Next.js
  • Fewer deployment guides and hosting templates
  • Less community content and tutorials
  • Now merged into React Router v7 (transition period)

Best for: Data-heavy applications, teams valuing web standards, progressive enhancement needs

SvelteKit (Svelte)

Strengths:

  • Smallest bundle sizes (compiler-based, no virtual DOM)
  • Simplest learning curve among frameworks
  • Built-in state management (reactive declarations)
  • Excellent performance out of the box
  • Growing ecosystem and community
  • First-class TypeScript support

Weaknesses:

  • Smaller ecosystem and component library selection
  • Fewer developers in hiring pool
  • Less enterprise adoption (harder to find case studies)
  • Fewer third-party integrations

Best for: Performance-critical applications, small teams wanting simplicity, developer experience priority

Frontend Decision Criteria

| Criterion | Next.js | Remix | SvelteKit | |-----------|---------|-------|-----------| | Ecosystem Size | Large | Medium | Growing | | Learning Curve | Medium | Medium | Low | | Performance | Good | Good | Excellent | | SSR/SSG | Excellent | Good | Good | | Hiring Pool | Large | Small | Small | | Bundle Size | Medium | Small | Smallest | | TypeScript | Excellent | Excellent | Excellent | | Deployment Flexibility | Medium | High | High |

Backend Frameworks

Node.js (Express / Fastify / NestJS)

Strengths:

  • Same language as frontend (JavaScript/TypeScript full-stack)
  • Massive npm ecosystem
  • NestJS provides enterprise patterns (DI, modules, decorators)
  • Excellent for I/O-heavy workloads
  • Large community and hiring pool
  • Great for real-time features (WebSockets)

Weaknesses:

  • Single-threaded (CPU-intensive tasks require workers)
  • Callback/async complexity
  • npm dependency security concerns
  • Less suited for computational workloads

Best for: Full-stack TypeScript teams, real-time applications, API-heavy products

Python (FastAPI / Django)

Strengths:

  • FastAPI: Modern, fast, automatic OpenAPI docs, async support
  • Django: Batteries included (admin, ORM, auth, migrations)
  • Excellent for data processing and ML integration
  • Clean, readable syntax
  • Strong ecosystem for analytics and data work
  • Large hiring pool across web and data roles

Weaknesses:

  • Slower runtime than Go/Rust (mitigated by async in FastAPI)
  • GIL limits true parallelism (multiprocessing required)
  • Django can feel heavyweight for microservices
  • Deployment can be more complex (WSGI/ASGI setup)

Best for: Data-heavy products, ML integration, rapid prototyping, admin-heavy applications

Go (Gin / Echo / Fiber)

Strengths:

  • Excellent performance (compiled, concurrent by design)
  • Low memory footprint
  • Simple deployment (single binary, no runtime)
  • Built-in concurrency (goroutines, channels)
  • Strong standard library
  • Fast compilation

Weaknesses:

  • Smaller web ecosystem than Node.js or Python
  • More verbose for CRUD operations
  • Error handling verbosity
  • Fewer ORM options (GORM is the main choice)
  • Steeper learning curve for teams from dynamic languages

Best for: High-throughput APIs, microservices, infrastructure tooling, performance-critical backends

Backend Decision Criteria

| Criterion | Node.js | Python | Go | |-----------|---------|--------|-----| | Performance | Good | Moderate | Excellent | | Developer Productivity | High | High | Medium | | Ecosystem | Largest | Large | Medium | | Hiring Pool | Large | Large | Medium | | Full-Stack Synergy | Excellent | None | None | | Data/ML Integration | Medium | Excellent | Low | | Concurrency | Event Loop | Async/Threads | Goroutines | | Deployment Simplicity | Medium | Medium | High |

Database

PostgreSQL

Strengths:

  • ACID compliant with excellent reliability
  • Rich feature set (JSON, full-text search, GIS, arrays)
  • Extensible (custom types, functions, extensions like PostGIS, pgvector)
  • Strong community and tooling
  • Excellent for complex queries and analytics
  • Free and open source with managed options (AWS RDS, Supabase, Neon)

Weaknesses:

  • Horizontal scaling requires effort (Citus, partitioning)
  • More complex initial setup than MySQL
  • VACUUM maintenance at high write volumes
  • Slightly slower for simple read-heavy workloads vs MySQL

Best for: Most SaaS applications (recommended default), complex data models, JSON workloads

MySQL

Strengths:

  • Proven at massive scale (Meta, Uber, Shopify)
  • Simpler replication setup
  • Faster for simple read-heavy workloads
  • PlanetScale offers serverless MySQL with branching
  • Wide hosting support

Weaknesses:

  • Fewer advanced features than PostgreSQL
  • Weaker JSON support
  • Less extensible
  • InnoDB limitations for certain workloads

Best for: Read-heavy applications, teams with MySQL expertise, PlanetScale users

Database Decision Criteria

| Criterion | PostgreSQL | MySQL | |-----------|-----------|-------| | Feature Richness | Excellent | Good | | JSON Support | Excellent | Moderate | | Replication | Good | Good | | Horizontal Scale | Moderate | Good (PlanetScale) | | Community | Excellent | Excellent | | Managed Options | Many | Many | | Learning Curve | Medium | Low | | Default Choice | Yes | Situational |

Caching Layer

Redis

Strengths:

  • Rich data structures (strings, hashes, lists, sets, sorted sets, streams)
  • Pub/Sub for real-time messaging
  • Lua scripting for atomic operations
  • Persistence options (RDB, AOF)
  • Cluster mode for horizontal scaling
  • Used for caching, sessions, queues, rate limiting, leaderboards

Weaknesses:

  • Memory-bound (dataset must fit in RAM)
  • Single-threaded command processing
  • Licensing changes (Redis 7.4+ source-available)
  • Cluster mode adds complexity

Best for: Most SaaS applications (recommended default), session management, rate limiting, queues

Memcached

Strengths:

  • Simplest possible key-value cache
  • Multi-threaded (better CPU utilization for simple operations)
  • Lower memory overhead per key
  • Predictable performance characteristics
  • Battle-tested at scale

Weaknesses:

  • No data structures (strings only)
  • No persistence
  • No pub/sub or scripting
  • No built-in clustering (client-side sharding)
  • Limited eviction policies

Best for: Pure caching use cases, simple key-value lookups, memory efficiency priority

Cache Decision Criteria

| Criterion | Redis | Memcached | |-----------|-------|-----------| | Data Structures | Rich | Strings Only | | Persistence | Yes | No | | Pub/Sub | Yes | No | | Multi-Threading | No (I/O threads in v6) | Yes | | Use Cases | Many | Caching Only | | Memory Efficiency | Good | Better | | Default Choice | Yes | Rarely |

Recommended Stacks by Product Type

B2B SaaS (Most Common)

  • Frontend: Next.js + TypeScript + shadcn/ui
  • Backend: Node.js (NestJS) or Python (FastAPI)
  • Database: PostgreSQL
  • Cache: Redis
  • Auth: Auth0 or Clerk
  • Payments: Stripe

Developer Tool / API Product

  • Frontend: Next.js or SvelteKit
  • Backend: Go (Gin) or Node.js (Fastify)
  • Database: PostgreSQL
  • Cache: Redis
  • Auth: Custom JWT + API Keys
  • Docs: Mintlify or ReadMe

Data-Heavy / Analytics Product

  • Frontend: Next.js
  • Backend: Python (FastAPI)
  • Database: PostgreSQL + ClickHouse (analytics)
  • Cache: Redis
  • Processing: Celery or Temporal
  • Visualization: Custom or embedded (Metabase)

Real-Time / Collaboration Product

  • Frontend: Next.js or SvelteKit
  • Backend: Node.js (Fastify) + WebSockets
  • Database: PostgreSQL + Redis (pub/sub)
  • Cache: Redis
  • Real-Time: Socket.io or Liveblocks
  • CRDT: Yjs or Automerge (for collaborative editing)