Roadmap Radar

An AI-powered signal intelligence layer that ingests customer feedback from Canny, deduplicates and scores grouped requests, and generates sprint-ready product artifacts — PRDs, story-pointed tasks, and Cursor implementation plans.

The system has two independent layers: an analysis pipeline that runs on-demand to process Canny boards, and a web application that serves the results, manages pipeline jobs, and triggers the AI agent chain on any grouped request.

The Analysis Pipeline

Every analysis run executes nine sequential stages. Runs are enqueued in Redis — one job processes at a time. Each stage checks a cancellation flag, so jobs can be stopped cleanly at any stage boundary.

From Group to Sprint-Ready Task

Triggered on-demand from any group detail page. Runs a four-agent chain that produces a full PRD, story-pointed sub-tasks, a feature spec, and a Cursor-executable implementation plan — all in under two minutes. Results are persisted and auto-loaded on every subsequent visit.

System Design

┌─────────────────────────────────────────────────────────┐
│  Next.js Frontend (localhost:3000 / Vercel)              │
│  Dashboard · Groups · Group Detail · Jobs · Login        │
└───────────────────────┬─────────────────────────────────┘
                        │ HTTP
┌───────────────────────▼─────────────────────────────────┐
│  FastAPI Backend (localhost:8000 / Cloud Run)            │
│                                                          │
│  /api/jobs       Job CRUD, cancel, cleanup               │
│  /api/groups     Search, filter, paginate                │
│  /api/boards     Live Canny board fetch                  │
│  /api/agents     PRD stream, result, config              │
│  /api/auth       Google OAuth / demo mode                │
└──────────┬───────────────────────┬───────────────────────┘
           │                       │
┌──────────▼──────┐   ┌────────────▼────────────────────┐
│  Redis          │   │  Filesystem                      │
│  job hashes     │   │  data/<board>/groups_with_...    │
│  job queue      │   │  data/prd_results/<group_id>/    │
│  pipeline lock  │   └─────────────────────────────────┘
└─────────────────┘
                        │ Agent pipeline only
         ┌──────────────┼──────────────┐
         ▼              ▼              ▼
    ClickUp API    GitHub Plans    OpenAI API
    Epic + tasks   Cursor plans    GPT-4o / mini

Technologies

Environment Variables

All configuration lives in backend/.env. The system starts in demo and mock mode with no required env vars — explore the UI and pre-computed data without any API keys.

# ClickUp — required for Live mode
CLICKUP_API_TOKEN=pk_...

# GitHub — optional, independent of ClickUp
# Fine-grained PAT: Contents Read+Write on plans repo only
GITHUB_TOKEN=github_pat_...
GITHUB_PLANS_REPO=your-org/roadmap-radar-plans

# Model overrides (optional — defaults shown)
AGENT_PRD_MODEL=gpt-4o
AGENT_TASKS_MODEL=gpt-4o-mini
AGENT_SPEC_MODEL=gpt-4o
AGENT_CODE_MODEL=gpt-5.4

Running Locally

The entire stack — backend, frontend, and Redis — runs via Docker Compose. No env vars are required to start. Pre-computed analysis results from the Automations, Voice AI, and Call Tracking boards are included.

Start everything

docker compose up --build

Enable live pipeline

To run the real pipeline against your Canny board, add to backend/.env:

MOCK_PIPELINE=false
CANNY_API_KEY=your-canny-api-key
OPENAI_API_KEY=your-openai-api-key
CANNY_BOARD_ID=your-default-board-id   # optional fallback

Then restart: docker compose restart backend

Deploying to Production

Production targets: GCP Cloud Run (backend), GCS (pipeline artifacts), Cloud Memorystore (Redis), Vercel (frontend). GCP infrastructure is already provisioned on staging.

# First time only
bash scripts/config.sh
source scripts/provision.env
bash scripts/provision.sh

# Every release
source scripts/provision.env
bash scripts/build.sh
bash scripts/deploy.sh

# Tear down
source scripts/provision.env
bash scripts/cleanup.sh [--keep-data] [--keep-images]

External Services

# Required for agent pipeline Live mode
CLICKUP_API_TOKEN=pk_...

# Fine-grained PAT: Contents Read+Write on plans repo only
GITHUB_TOKEN=github_pat_...
GITHUB_PLANS_REPO=your-org/roadmap-radar-plans

# Feature: [Sub-task name]

## Context
Problem statement, user issues, and proposed solution
derived from the PRD and group insights.

## Implementation Plan

### Step 1 — [File path]
TDD approach: write the test first.
```
// test/path/to/spec.test.ts
describe('feature', () => { ... })
```
Command: `npm test path/to/spec`

### Step 2 — [File path]
Implementation guidance with exact file paths.

## Cursor Skills
@skill brainstorming
@skill test-driven-development

Future Enhancements

The architecture is designed to accommodate these additions without structural changes.