QQQ is built as a modular framework where each module has a specific responsibility. This gives you the flexibility to include only what you need while maintaining clean separation of concerns.

graph TB
    subgraph "Backend Core"
        A[qqq-backend-core<br/>Foundation Framework]
    end
    
    subgraph "Backend Modules"
        B1[qqq-backend-module-rdbms<br/>Relational Databases]
        B2[qqq-backend-module-filesystem<br/>File & S3 Operations]
        B3[qqq-backend-module-mongodb<br/>Document Database]
        B4[qqq-backend-module-sqlite<br/>Embedded Database]
    end
    
    subgraph "Middleware"
        C1[qqq-middleware-javalin<br/>HTTP Server]
        C2[qqq-middleware-picocli<br/>CLI Commands]
        C3[qqq-middleware-lambda<br/>AWS Lambda]
        C4[qqq-middleware-slack<br/>Slack Integration]
    end
    
    subgraph "Frontend & Support"
        D1[qqq-frontend-material-dashboard<br/>React Dashboard]
        D2[qqq-openapi<br/>API Documentation]
        D3[qqq-language-support-javascript<br/>JS Execution]
    end
    
    A --> B1
    A --> B2
    A --> B3
    A --> B4
    
    A --> C1
    A --> C2
    A --> C3
    A --> C4
    
    A --> D1
    A --> D2
    A --> D3

Purpose: The heart of QQQ that everything else builds on.

What it provides:

• Action Framework: AbstractQActionFunction for business logic
• Context Management: Thread-local state via QContext
• Metadata Models: QInstance container for application configuration
• Scheduler: Job scheduling and automation
• Logging: Structured logging system
• Exception Handling: QException hierarchy

Dependencies: None (this is the foundation) When to use: Always - every QQQ application needs this.

Purpose: Handle all relational database operations.

What it provides:

• Database Operations: CRUD operations, queries, transactions
• Connection Pooling: C3P0-based connection management
• SQL Support: MySQL, PostgreSQL, SQL Server, H2
• Transaction Management: ACID compliance with rollback support
• Query Optimization: Join graphs and metadata-driven queries

Dependencies: qqq-backend-core When to use: When you need to work with relational data (most applications).

Purpose: Handle file operations across different storage backends.

What it provides:

• Local Files: Standard file system operations
• AWS S3: Cloud storage integration
• SFTP: Secure file transfer operations
• Path Management: Cross-platform path handling
• File Metadata: Size, timestamps, permissions

Dependencies: qqq-backend-core When to use: File uploads, document storage, backup operations.

Purpose: Handle MongoDB document operations.

What it provides:

• Document CRUD: Create, read, update, delete documents
• Aggregation: MongoDB aggregation pipelines
• Indexing: Document indexing and optimization
• Connection Management: MongoDB driver integration

Dependencies: qqq-backend-core When to use: Document-based data, JSON-like structures, NoSQL requirements.

Purpose: Lightweight, embedded database operations.

What it provides:

• Embedded Database: No separate database server needed
• File-based Storage: Single file contains entire database
• SQL Support: Standard SQL operations
• Zero Configuration: Works out of the box

Dependencies: qqq-backend-core When to use: Development, testing, embedded applications, simple deployments.

Purpose: Provide REST API and web interface.

What it provides:

• HTTP Server: Embedded web server with REST endpoints
• API Routing: Automatic route generation from QQQ actions
• Frontend Serving: Hosts React dashboard
• Hot Reloading: Development-time metadata updates

Dependencies: qqq-backend-core When to use: Web applications, REST APIs, browser-based interfaces.

Purpose: Command-line interface for QQQ applications.

What it provides:

• CLI Framework: Command-line argument parsing
• Action Integration: Expose QQQ actions as CLI commands
• Batch Processing: Run actions from command line
• Scripting: Automate QQQ operations

Dependencies: qqq-backend-core When to use: Server administration, batch processing, automation scripts.

Purpose: Serverless deployment of QQQ actions.

What it provides:

• Lambda Integration: Deploy actions as serverless functions
• Event Handling: Process AWS events (S3, SQS, etc.)
• Scalability: Automatic scaling based on demand
• Cost Optimization: Pay only for execution time

Dependencies: qqq-backend-core When to use: Event-driven processing, serverless architectures, AWS integration.

Purpose: Slack bot integration for QQQ applications.

What it provides:

• Slack Bot: Interactive bot for Slack workspaces
• Action Commands: Execute QQQ actions via Slack
• Notifications: Send QQQ events to Slack channels
• User Interaction: Chat-based interface to QQQ

Dependencies: qqq-backend-core When to use: Team collaboration, notifications, chat-based interfaces.

Purpose: Modern web interface for QQQ applications.

What it provides:

• React 18: Modern UI framework with hooks
• TypeScript: Type-safe development
• Material-UI: Professional component library
• QQQ Integration: Metadata-driven UI generation
• Custom Widgets: Extensible widget system

Dependencies: Node.js, npm/yarn When to use: Web dashboards, admin panels, user interfaces.

Purpose: Generate OpenAPI specifications for QQQ APIs.

What it provides:

• API Documentation: Automatic OpenAPI spec generation
• Swagger UI: Interactive API documentation
• Client Generation: Generate client libraries
• API Testing: Built-in API testing interface

Dependencies: qqq-backend-core When to use: API documentation, client library generation, API testing.

Purpose: Execute JavaScript within QQQ applications.

What it provides:

• JavaScript Engine: Nashorn or GraalJS integration
• Action Scripting: Write actions in JavaScript
• Dynamic Logic: Runtime JavaScript execution
• Integration: Bridge between JavaScript and Java

Dependencies: qqq-backend-core When to use: Dynamic business logic, JavaScript developers, rapid prototyping.

<dependency>
    <groupId>com.kingsrook.qqq</groupId>
    <artifactId>qqq-backend-core</artifactId>
    <version>${qqq.version}</version>
</dependency>

<!-- RDBMS Support -->
<dependency>
    <groupId>com.kingsrook.qqq</groupId>
    <artifactId>qqq-backend-module-rdbms</artifactId>
    <version>${qqq.version}</version>
</dependency>

<!-- Filesystem Support -->
<dependency>
    <groupId>com.kingsrook.qqq</groupId>
    <artifactId>qqq-backend-module-filesystem</artifactId>
    <version>${qqq.version}</version>
</dependency>

<!-- HTTP Server -->
<dependency>
    <groupId>com.kingsrook.qqq</groupId>
    <artifactId>qqq-middleware-javalin</artifactId>
    <version>${qqq.version}</version>
</dependency>

<!-- CLI Commands -->
<dependency>
    <groupId>com.kingsrook.qqq</groupId>
    <artifactId>qqq-middleware-picocli</artifactId>
    <version>${qqq.version}</version>
</dependency>

For architecture details, see High-Level Architecture. For development workflow, see Building Locally. For API details, see Public API Overview.