multitenetsaas/specs/001-1-target-sectors/plan.md

Implementation Plan: Multi-Tenant SaaS Platform for Malaysian SMEs

Branch: 001-1-target-sectors | Date: 2025-10-04 | Spec: /specs/001-1-target-sectors/spec.md Input: Feature specification from /specs/001-1-target-sectors/spec.md

Execution Flow (/plan command scope)

1. Load feature spec from Input path
   → If not found: ERROR "No feature spec at {path}"
2. Fill Technical Context (scan for NEEDS CLARIFICATION)
   → Detect Project Type from file system structure or context (web=frontend+backend, mobile=app+api)
   → Set Structure Decision based on project type
3. Fill the Constitution Check section based on the content of the constitution document.
4. Evaluate Constitution Check section below
   → If violations exist: Document in Complexity Tracking
   → If no justification possible: ERROR "Simplify approach first"
   → Update Progress Tracking: Initial Constitution Check
5. Execute Phase 0 → research.md
   → If NEEDS CLARIFICATION remain: ERROR "Resolve unknowns"
6. Execute Phase 1 → contracts, data-model.md, quickstart.md, agent-specific template file (e.g., `CLAUDE.md` for Claude Code, `.github/copilot-instructions.md` for GitHub Copilot, `GEMINI.md` for Gemini CLI, `QWEN.md` for Qwen Code, or `AGENTS.md` for all other agents).
7. Re-evaluate Constitution Check section
   → If new violations: Refactor design, return to Phase 1
   → Update Progress Tracking: Post-Design Constitution Check
8. Plan Phase 2 → Describe task generation approach (DO NOT create tasks.md)
9. STOP - Ready for /tasks command

IMPORTANT: The /plan command STOPS at step 7. Phases 2-4 are executed by other commands:

• Phase 2: /tasks command creates tasks.md
• Phase 3-4: Implementation execution (manual or via tools)

Summary

Multi-tenant SaaS platform targeting Malaysian SMEs with industry-specific modules (Retail, Healthcare, Education, Logistics, Beauty). Features include modular architecture, dual pricing models (subscription and perpetual license), multi-tenant data isolation, and comprehensive business management tools for each sector.

Technical Context

Language/Version: Python 3.11+ with Django/FastAPI for backend, React/Next.js for frontend Primary Dependencies: Django/FastAPI, PostgreSQL, React/Next.js, Stripe API, Redis, Docker Storage: PostgreSQL with row-level security for multi-tenant isolation Testing: pytest for backend, Jest for frontend, integration tests for APIs Target Platform: Web-based SaaS platform (Linux servers) Project Type: Web application (backend + frontend) Performance Goals: 1000 concurrent users, <200ms response time for 95% of requests Constraints: Multi-tenant data isolation, Malaysian payment method integration, healthcare compliance standards Scale/Scope: 100 tenants with 10 users each (expandable), 5 industry modules

Constitution Check

GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.

Constitution Status: Template placeholders detected - actual constitution needs to be defined

• Core principles not yet defined
• Testing approach needs constitutional alignment
• Governance structure requires specification

Recommendation: Define constitution before proceeding with implementation to ensure alignment with project values and standards.

Project Structure

Documentation (this feature)

specs/001-1-target-sectors/
├── plan.md              # This file (/plan command output)
├── research.md          # Phase 0 output (/plan command)
├── data-model.md        # Phase 1 output (/plan command)
├── quickstart.md        # Phase 1 output (/plan command)
├── contracts/           # Phase 1 output (/plan command)
└── tasks.md             # Phase 2 output (/tasks command - NOT created by /plan)

Source Code (repository root)

backend/
├── src/
│   ├── core/                 # Core multi-tenant infrastructure
│   │   ├── models/          # Base tenant, user, subscription models
│   │   ├── auth/            # Authentication and authorization
│   │   ├── billing/         # Subscription and payment handling
│   │   └── admin/           # Back office administration
│   ├── modules/             # Industry-specific modules
│   │   ├── retail/          # Retail & Food Stalls module
│   │   ├── healthcare/      # Healthcare module
│   │   ├── education/      # Education module
│   │   ├── logistics/       # Logistics module
│   │   └── beauty/          # Beauty & Personal Care module
│   └── api/                # REST API endpoints
├── tests/
│   ├── contract/            # API contract tests
│   ├── integration/         # Module integration tests
│   └── unit/               # Unit tests
└── migrations/             # Database migrations

frontend/
├── src/
│   ├── components/         # Reusable UI components
│   ├── pages/              # Application pages
│   ├── modules/            # Module-specific components
│   ├── hooks/              # Custom React hooks
│   ├── services/           # API service layer
│   └── utils/              # Utility functions
├── tests/                  # Frontend tests
└── public/                 # Static assets

shared/
├── types/                  # TypeScript type definitions
└── contracts/             # Shared API contracts

docker/                     # Docker configuration
├── backend/
├── frontend/
└── postgres/

docs/                       # Project documentation
└── api/                    # API documentation

Structure Decision: Web application with separate backend/frontend for scalability and independent deployment. Modular backend structure allows for plug-and-play industry modules. Shared types ensure API consistency.

Progress Tracking

• Phase 0: Research completed (research.md generated)
• Phase 1: Design completed (data-model.md, contracts/, quickstart.md generated)
• Phase 2: Task planning (122 tasks created in tasks.md)
• Phase 3: Task execution (ready to begin)
• Phase 4: Implementation (pending)
• Phase 5: Validation (pending)

Phase 0: Outline & Research

1. Extract unknowns from Technical Context above:

   • For each NEEDS CLARIFICATION → research task
   • For each dependency → best practices task
   • For each integration → patterns task

2. Generate and dispatch research agents:

   For each unknown in Technical Context:
     Task: "Research {unknown} for {feature context}"
   For each technology choice:
     Task: "Find best practices for {tech} in {domain}"
   

3. Consolidate findings in research.md using format:

   • Decision: [what was chosen]
   • Rationale: [why chosen]
   • Alternatives considered: [what else evaluated]

Output: research.md with all NEEDS CLARIFICATION resolved

Phase 1: Design & Contracts

Prerequisites: research.md complete

1. Extract entities from feature spec → data-model.md:

   • Entity name, fields, relationships
   • Validation rules from requirements
   • State transitions if applicable

2. Generate API contracts from functional requirements:

   • For each user action → endpoint
   • Use standard REST/GraphQL patterns
   • Output OpenAPI/GraphQL schema to /contracts/

3. Generate contract tests from contracts:

   • One test file per endpoint
   • Assert request/response schemas
   • Tests must fail (no implementation yet)

4. Extract test scenarios from user stories:

   • Each story → integration test scenario
   • Quickstart test = story validation steps

5. Update agent file incrementally (O(1) operation):

   • Run .specify/scripts/bash/update-agent-context.sh claude IMPORTANT: Execute it exactly as specified above. Do not add or remove any arguments.
   • If exists: Add only NEW tech from current plan
   • Preserve manual additions between markers
   • Update recent changes (keep last 3)
   • Keep under 150 lines for token efficiency
   • Output to repository root

Output: data-model.md, /contracts/*, failing tests, quickstart.md, agent-specific file

Phase 2: Task Planning Approach

This section describes what the /tasks command will do - DO NOT execute during /plan

Task Generation Strategy:

• Load .specify/templates/tasks-template.md as base
• Generate tasks from Phase 1 design docs (contracts, data model, quickstart)
• Each contract → contract test task [P]
• Each entity → model creation task [P]
• Each user story → integration test task
• Implementation tasks to make tests pass

Ordering Strategy:

• TDD order: Tests before implementation
• Dependency order: Models before services before UI
• Mark [P] for parallel execution (independent files)

Estimated Output: 25-30 numbered, ordered tasks in tasks.md

IMPORTANT: This phase is executed by the /tasks command, NOT by /plan

Phase 3+: Future Implementation

These phases are beyond the scope of the /plan command

Phase 3: Task execution (/tasks command creates tasks.md)
Phase 4: Implementation (execute tasks.md following constitutional principles)
Phase 5: Validation (run tests, execute quickstart.md, performance validation)

Complexity Tracking

Fill ONLY if Constitution Check has violations that must be justified

Violation	Why Needed	Simpler Alternative Rejected Because
[e.g., 4th project]	[current need]	[why 3 projects insufficient]
[e.g., Repository pattern]	[specific problem]	[why direct DB access insufficient]

Progress Tracking

This checklist is updated during execution flow

Phase Status:

• Phase 0: Research complete (/plan command)
• Phase 1: Design complete (/plan command)
• Phase 2: Task planning complete (/plan command - describe approach only)
• Phase 3: Tasks generated (/tasks command)
• Phase 4: Implementation complete
• Phase 5: Validation passed

Gate Status:

• Initial Constitution Check: PASS
• Post-Design Constitution Check: PASS
• All NEEDS CLARIFICATION resolved
• Complexity deviations documented

---

Based on Constitution v2.1.1 - See /memory/constitution.md