DEV Community

Cover image for The RapidKit Ecosystem: Three Tools, One Vision
RapidKit
RapidKit

Posted on

The RapidKit Ecosystem: Three Tools, One Vision

#rapidkit #opensource #api #devtools

You Don't Need Another Framework

You need a workflow.

Backend development in 2026 isn't about picking the right web framework.
FastAPI is mature. NestJS is mature.

The problem isn't building APIs.
The problem is the everything else:

  • Setting up projects consistently
  • Managing dependencies across services
  • Organizing code in a way that scales
  • Onboarding new developers without friction
  • Maintaining multiple APIs without chaos

This is where most teams struggle.

And this is what RapidKit was built to solve.

One Problem, Three Tools

RapidKit isn't a monolithic framework.
It's an ecosystem of three focused tools that work together seamlessly:

  1. RapidKit Core (Python Engine)
  2. RapidKit CLI (npm Package)
  3. RapidKit for VS Code (Extension)

Each tool solves a specific part of the workflow.
Together, they eliminate the friction in modern backend development.

1️⃣ RapidKit Core: The Brain

Language: Python

Install: pip/pipx install rapidkit-core

Role: Project generation, module management, and architecture enforcement

This is where the real work happens.

RapidKit Core is a Python-powered engine that:

  • Generates FastAPI and NestJS projects with clean architecture
  • Manages 27+ plug-and-play modules (auth, databases, caching, logging, etc.)
  • Maintains project structure and tracks file changes
  • Handles dependency resolution and environment setup
  • Powers the CLI and VS Code extension behind the scenes

Example:

rapidkit create project fastapi.standard my-api
rapidkit add module settings
rapidkit add module auth_core
rapidkit add module db_postgres
rapidkit add module redis
Enter fullscreen mode Exit fullscreen mode

In four commands, you get:

  • A production-ready FastAPI project
  • Multi-source configuration management
  • PBKDF2 password hashing + HMAC token signing
  • PostgreSQL with async SQLAlchemy and connection pooling
  • Redis caching with retry logic
  • Docker and health endpoints included

Module System:

  • 27+ free modules across 13 categories
  • Uniform architecture: every module has module.yaml, docs/usage.md, and generate.py
  • Framework variants: each module supports FastAPI and NestJS
  • Environment overrides: RAPIDKIT_<MODULE>_<SETTING> pattern

Generation Workflow:

module.yaml → generate.py → vendor artifacts → framework plugin → project files
Enter fullscreen mode Exit fullscreen mode

No templates. No boilerplate copy-paste. Just generated, version-tracked code.

2️⃣ RapidKit CLI: The Bridge

Language: Node.js (TypeScript)

Install: npm install -g rapidkit (or use npx)

Role: Developer-friendly interface and workspace orchestration

The CLI is your primary interface with RapidKit.

It bridges the gap between your terminal and the Python engine, handling:

  • Workspace creation and management
  • Project lifecycle commands (init, dev, test, build)
  • Environment detection (Python, Node, Poetry, etc.)
  • Command delegation to projects or Core
  • Cross-platform compatibility (Windows, Linux, macOS)

Why Node.js?

Because most developers already have Node installed.

You don't need to think about Python environments or Poetry setup — the CLI handles it automatically when you create a workspace.

Example workflow:

# Create a workspace (sets up Python environment)
npx rapidkit my-workspace
cd my-workspace

# Create projects
rapidkit create project fastapi.standard api-gateway
rapidkit create project nestjs.standard user-service

# Start developing
cd api-gateway
rapidkit dev  # Starts FastAPI server at :8000
Enter fullscreen mode Exit fullscreen mode

The CLI is smart:

  • Inside workspace directory? Uses workspace .venv/bin/rapidkit (shared Core)
  • Outside workspace? Uses npm bridge to invoke Core
  • Inside a project? Detects .rapidkit/ and runs project commands (dev, test)
  • Command rapidkit (no npx)? Looks for workspace virtualenv first, then global install

3️⃣ RapidKit for VS Code: The Interface

Platform: VS Code Extension

Install: VS Code Marketplace

Role: Visual project management and discovery

Some developers prefer the command line.
Others prefer a GUI.

RapidKit for VS Code gives you both.

Key features:

  • Welcome Panel: Central hub for workspaces and projects
  • Module Browser: Browse and install 27+ modules with one click
  • Setup Status: Verify your development environment (Python, CLI, Core)
  • Workspace Health: Check any workspace for issues
  • Project Creation: Visual wizard for FastAPI/NestJS projects
  • Sidebar Integration: All your workspaces and projects in one place

Example:

  1. Open VS Code
  2. Ctrl+Shift+P → "RapidKit: Create Project"
  3. Choose FastAPI or NestJS
  4. Enter project name
  5. Done.

Your project is ready with:

  • Full project structure
  • Dependencies configured
  • Dev server ready to start
  • API docs waiting at /docs

No terminal commands needed.

How They Work Together

Here's the real power:

Each tool handles what it's best at, but they're deeply integrated.

Scenario 1: CLI-First Workflow 

# Create workspace via CLI
npx rapidkit my-workspace
cd my-workspace

# Create project via CLI
rapidkit create project fastapi.standard api

# Open in VS Code
code .
Enter fullscreen mode Exit fullscreen mode

Result: VS Code extension auto-discovers the workspace, shows all projects in the sidebar, and offers module installation via GUI.

Scenario 2: VS Code-First Workflow

  1. Open VS Code
  2. Use extension to create workspace
  3. Use extension to create projects
  4. Use extension to install modules

Result: Everything is tracked in ~/.rapidkit/workspaces.json. Open a terminal and rapidkit commands work instantly.

Scenario 3: Mixed Workflow (Most Common)

  • Use CLI for fast project creation
  • Use VS Code for module browsing and installation
  • Use CLI for development commands (dev, test, build)
  • Use VS Code for health checks and workspace management

The ecosystem adapts to your workflow.

RapidKit Modules: The Building Blocks

RapidKit Core provides 27+ production-ready modules organized into 13 categories:

🔐 Authentication & Authorization

  • auth/core — PBKDF2 password hashing + HMAC tokens
  • auth/api_keys — API key management
  • auth/oauth — OAuth2 providers (Google, GitHub, etc.)
  • auth/session — Session management
  • auth/passwordless — Magic link authentication

💾 Database

  • database/db_postgres — Async/sync PostgreSQL with pooling
  • database/db_mongo — MongoDB integration
  • database/db_sqlite — SQLite for prototyping

⚡ Caching & Performance

  • cache/redis — Async Redis with retry logic

🔒 Security

  • security/cors — CORS middleware with whitelisting
  • security/headers — Security headers (CSP, HSTS, etc.)
  • security/rate_limiting — Rate limiting

📧 Communication

  • communication/email — Email sending
  • communication/notifications — Push notifications

⚙️ Essentials

  • essentials/settings — Multi-source configuration
  • essentials/middleware — Custom middleware
  • essentials/logging — Structured logging
  • essentials/deployment — Deployment configs

📊 Observability

  • observability/core — Metrics and tracing

⏱️ Background Tasks

  • tasks/celery — Celery integration

👥 User Management

  • users/core — User models and CRUD
  • users/profiles — User profiles

Every module provides:

  • ✅ Framework variants (FastAPI + NestJS)
  • ✅ Health endpoint (/api/health/module/<name>)
  • ✅ Environment-based configuration
  • ✅ Usage documentation (docs/usage.md)
  • ✅ Testing setup

Why Three Tools Instead of One?

Because focus matters.

  • Python Core: Best for project generation and module logic
  • Node.js CLI: Best for developer accessibility and environment detection
  • VS Code Extension: Best for visual discovery and onboarding

Trying to cram everything into one tool creates complexity.
Separating concerns creates simplicity.

Under the Hood: Architecture 

┌─────────────────────────────────────────┐
│       VS Code Extension                 │
│  (Visual interface & workspace manager) │
└────────────────┬────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────┐
│          RapidKit CLI (npm)             │
│    (Command routing & delegation)       │
└────────────────┬────────────────────────┘
                 │
      ┏━━━━━━━━━┻━━━━━━━━━┓
      ▼                    ▼
┌──────────────┐   ┌──────────────────┐
│ Project CLI  │   │  RapidKit Core   │
│  (Launcher)  │   │ (Python Engine)  │
└──────────────┘   └──────────────────┘
      │                    │
      └─────────┬──────────┘
                ▼
      ┌──────────────────┐
      │ Generated Project│
      │ (FastAPI/NestJS) │
      └──────────────────┘
Enter fullscreen mode Exit fullscreen mode

Key insight: The CLI and Extension never generate code directly. They delegate to RapidKit Core, which ensures consistency across all entry points.

What This Means for You

If you're a solo developer:

  • Use the CLI for speed
  • Use VS Code for discovery
  • Pick what fits your workflow

If you're on a team:

  • Use VS Code for onboarding
  • Use CLI for automation and CI/CD
  • Use workspaces to enforce consistency

If you're evaluating RapidKit:

  • Start with workspace creation (npx rapidkit my-workspace)
  • Install VS Code extension to explore modules visually
  • Try all three approaches and pick your favorite

There's no lock-in. All three tools share the same project format.

The Vision: Invisible Infrastructure

The goal isn't to make you think about RapidKit.

The goal is to make you forget about boilerplate and focus on building features.

  • Core generates the foundation
  • CLI keeps you productive
  • VS Code keeps you organized

And behind the scenes, everything stays consistent, maintainable, and production-ready.

Try It Yourself

Pick your entry point:

CLI:

npx rapidkit my-workspace
Enter fullscreen mode Exit fullscreen mode

VS Code:

  1. Install RapidKit extension
  2. Ctrl+Shift+P → "RapidKit: Create Workspace"

Python directly:

# Recommended: isolated install
pipx install rapidkit-core

# Or: standard install
pip install rapidkit-core

# Create project
rapidkit create project fastapi.standard my-api
Enter fullscreen mode Exit fullscreen mode

💡 Recommendation: Start with the workspace approach (npx rapidkit my-workspace) for the best experience — it handles all prerequisites automatically.

All three paths lead to the same place: production-ready FastAPI and NestJS projects in minutes.

Learn More

Next Article

In the next post, we'll explore Workspace-First Development — why organizing multiple projects in one environment changes everything for backend teams.

Stay tuned.

Top comments (0)