🚀 AI-Powered PRD Builder

AI PRD is a comprehensive Product Requirements Document (PRD) management platform that combines AI-assisted content generation with stakeholder collaboration, feature prioritization, and seamless integration with popular project management tools.

📋 Table of Contents

Overview
Key Features
Tech Stack
Getting Started
Usage
Architecture
API Documentation
Development
Deployment
Contributing
License

🎯 Overview

AI PRD is designed for product managers and teams who need to create, manage, and collaborate on Product Requirements Documents efficiently. The platform leverages Google's Gemini AI to assist in:

🤖 AI-Assisted Writing: Generate user stories, acceptance criteria, and requirements
📊 RICE Prioritization: Systematic feature prioritization using Reach, Impact, Confidence, and Effort metrics
👥 Stakeholder Management: Collect feedback, track reviews, and manage alignment
🔄 Version Control: Snapshot system with full state versioning and burndown tracking
🔗 Integrations: Sync with Linear, Jira, and Notion
📤 Export Options: PDF, HTML, and JSON exports with shareable links
🌐 Internationalization: Multi-language support (English, Spanish)

✨ Key Features

Frontend Features

Feature	Description
PRD Builder	Step-by-step editor with AI assistance and template selection
Command Palette	Cmd/Ctrl+K global shortcuts for quick navigation and actions
Feature Prioritization	RICE scoring matrix for data-driven decision making
Stakeholder Input	Structured feedback collection and review tracking
AI Assistant Panel	Real-time suggestions for user stories, requirements, and gap detection
Snapshot History	Version control with timestamps and restore capabilities
Survey Intake	Collect structured feedback from stakeholders and users
Theme Support	Light/dark mode with persistence
Offline Support	PWA with local-first data storage
Telemetry	Optional Sentry integration for error tracking and analytics
Smart Caching	AI response caching (1 min TTL) for instant suggestions
Secret Detection	Warns before committing sensitive data
Accessibility	ARIA labels, keyboard navigation, screen reader support

Backend Features

Feature	Description
PRD Management	Full CRUD operations for PRDs with validation
Snapshot System	Compressed version history with gzip support
Linear Integration	Create and sync issues to Linear
Jira Integration	Create and sync issues to Jira
Notion Export	Convert PRDs to Notion pages with markdown support
Custom Templates	Create and manage reusable PRD templates
Job Queue	Async processing for long-running sync operations
Data Security	Server-side redaction of sensitive information
Rate Limiting	Protection against API abuse
Health Checks	System health monitoring endpoint

🛠 Tech Stack

Frontend

Core:

⚛️ React 18.3.1 with TypeScript
⚡ Vite 7.1.4 - Modern build tool with HMR
🎨 Tailwind CSS 3.4.17 - Utility-first styling
🗺 React Router 6.27.0 - Client-side routing
🐻 Zustand 5.0.8 - Lightweight state management

AI & Services:

🤖 Google Generative AI - Gemini API integration
🔐 Clerk - Authentication and user management
📊 Sentry - Error tracking and telemetry
📄 jsPDF - PDF export functionality

Development:

🧪 Vitest - Unit testing
🧹 ESLint + Prettier - Code quality and formatting
✅ Zod - Schema validation

Backend

Core:

🟢 Node.js with TypeScript
🚂 Express.js 4.19.2 - REST API framework
🍃 MongoDB + Mongoose 8.6.0 - Database and ODM

Integrations:

📋 Notion API - Export to Notion pages
🎯 Linear API - GraphQL-based issue tracking
📌 Jira API - REST-based issue tracking

Development:

⚡ tsx - TypeScript execution with hot reload
✅ Zod - Runtime schema validation
🌐 CORS - Cross-origin resource sharing

🚀 Getting Started

Prerequisites

Node.js >= 18.x
npm >= 9.x
MongoDB >= 6.x (local or cloud instance)
Google Gemini API Key (for AI features)
Optional: Linear, Jira, and Notion API keys (for integrations)

Installation

Clone the repository:

git clone https://github.com/devagarwal07/AIPRD.git
cd AIPRD

Install Frontend Dependencies:
```
cd Frontend
npm install
```
Install Backend Dependencies:
```
cd ../server
npm install
```

Configuration

Frontend Configuration

Create a .env file in the Frontend directory:

# Required: Google Gemini API
VITE_GEMINI_API_KEY=your_gemini_api_key_here
VITE_GEMINI_MODEL=gemini-1.5-flash

# Optional: Backend API URL
VITE_API_BASE=http://localhost:4000

# Optional: Authentication (Clerk)
VITE_CLERK_PUBLISHABLE_KEY=your_clerk_key_here

# Optional: Error Tracking (Sentry)
VITE_SENTRY_DSN=your_sentry_dsn_here

Getting API Keys:

Gemini API: Visit Google AI Studio
Clerk: Visit Clerk Dashboard
Sentry: Visit Sentry.io

Backend Configuration

Create a .env file in the server directory:

# Required: Database
MONGODB_URI=mongodb://localhost:27017/pmcopilot
PORT=4000

# Optional: Linear Integration
LINEAR_API_KEY=your_linear_api_key

# Optional: Jira Integration
JIRA_BASE_URL=https://your-domain.atlassian.net
JIRA_EMAIL=your_email@example.com
JIRA_API_TOKEN=your_jira_token

# Optional: Notion Integration
NOTION_API_KEY=your_notion_integration_token
NOTION_PARENT_PAGE=your_parent_page_id
NOTION_PARENT_DB=your_parent_database_id

Getting Integration Keys:

Linear API: Settings → API → Personal API Keys
Jira API: Account Settings → Security → API Tokens
Notion API: Create an integration

💻 Usage

Development Mode

Option 1: Run Frontend and Backend Separately

Terminal 1 (Backend):

cd server
npm run dev
# Server starts on http://localhost:4000

Terminal 2 (Frontend):

cd Frontend
npm run dev
# App starts on http://localhost:5173

Option 2: Run Both Together

cd Frontend
npm run dev:all
# Starts both frontend and backend concurrently

Production Build

Frontend:

cd Frontend
npm run build
npm run preview  # Preview the production build

Backend:

cd server
npm run build
npm start

Testing

Frontend Tests:

cd Frontend
npm run test        # Watch mode
npm run test:run    # Single run

Code Quality

Frontend:

npm run lint      # Check code quality
npm run format    # Auto-format code
npm run analyze   # Bundle size analysis

🏗 Architecture

System Overview

┌─────────────────────────────────────────────────────┐
│                   Frontend (React)                   │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│  │ PRD Builder  │  │  Dashboard   │  │ Snapshots │ │
│  └──────────────┘  └──────────────┘  └───────────┘ │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│  │AI Assistant  │  │Prioritization│  │  Export   │ │
│  └──────────────┘  └──────────────┘  └───────────┘ │
└─────────────────────────────────────────────────────┘
                         │
                         ├─── Google Gemini API (AI)
                         │
                         ↓
┌─────────────────────────────────────────────────────┐
│               Backend (Express + MongoDB)            │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│  │  PRD Routes  │  │ Sync Routes  │  │Integrations│ │
│  └──────────────┘  └──────────────┘  └───────────┘ │
│                                                      │
│  ┌──────────────────────────────────────────────┐  │
│  │           MongoDB (Data Layer)                │  │
│  │  • PRDs  • Snapshots  • Templates  • Config  │  │
│  └──────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘
                         │
        ┌────────────────┼────────────────┐
        │                │                │
    Linear API       Jira API       Notion API

Frontend Architecture

State Management:

Zustand store (prdStore.ts) as single source of truth
LocalStorage persistence for offline support
Snapshot system for version control

Component Structure:

App
├── Router
│   ├── Dashboard (PRD list, search, filters)
│   ├── PRDBuilder
│   │   ├── StepEditor (Overview, Goals, Features, etc.)
│   │   ├── AssistantPanel (AI suggestions)
│   │   ├── SnapshotPanel (Version history)
│   │   └── ExportPanel (PDF, HTML, JSON)
│   ├── PrioritizationMatrix (RICE scoring)
│   ├── StakeholderInput (Feedback collection)
│   └── ReadOnlyPRD (Shareable view)
├── CommandPalette (Cmd/Ctrl+K shortcuts)
└── ErrorBoundary (Error handling)

Backend Architecture

Route Structure:

/api
├── /prds              # PRD CRUD operations
├── /snapshots         # Version history
├── /sync              # Linear & Jira sync
│   ├── /linear        # Create Linear issues
│   ├── /jira          # Create Jira issues
│   └── /jobs          # Job queue status
├── /integrations      # Config management
├── /templates         # Custom templates
├── /notion           # Notion export
└── /health           # Health check

Data Models:

PRD: Core document with metadata, sections, features
Snapshot: Compressed version history with timestamps
IntegrationConfig: User-specific integration settings
Template: Custom PRD templates

📚 API Documentation

PRD Endpoints

`GET /api/prds`

List all PRDs (50 most recent)

Response:

[
  {
    "_id": "...",
    "title": "New Feature PRD",
    "metadata": { "owner": "..." },
    "createdAt": "2026-01-31T...",
    "updatedAt": "2026-01-31T..."
  }
]

`POST /api/prds`

Create a new PRD

Request Body:

{
  "title": "New Feature PRD",
  "metadata": {
    "owner": "John Doe",
    "status": "draft"
  },
  "sections": {
    "overview": "Product overview...",
    "goals": ["Goal 1", "Goal 2"]
  }
}

`PUT /api/prds/:id`

Update an existing PRD

`DELETE /api/prds/:id`

Delete a PRD

Snapshot Endpoints

`GET /api/snapshots/:prdId`

List snapshots for a specific PRD

`POST /api/snapshots`

Create a snapshot

Request Body:

{
  "prdId": "...",
  "snapshot": { "title": "...", "sections": {...} },
  "version": "1.0.0",
  "comment": "Initial version"
}

Sync Endpoints

`POST /api/sync/linear`

Create issues in Linear

Request Body:

{
  "teamId": "...",
  "projectId": "...",
  "features": [
    {
      "title": "Feature 1",
      "description": "...",
      "priority": 1
    }
  ],
  "async": false
}

`POST /api/sync/jira`

Create issues in Jira

Request Body:

{
  "projectKey": "PROJ",
  "features": [
    {
      "title": "Feature 1",
      "description": "...",
      "issueType": "Story"
    }
  ]
}

`GET /api/sync/jobs/:id`

Get sync job status

Response:

{
  "id": "...",
  "status": "completed",
  "result": {
    "created": 5,
    "failed": 0,
    "issues": [...]
  }
}

Notion Endpoints

`POST /api/notion/page`

Create a Notion page from markdown

Request Body:

{
  "title": "PRD Title",
  "markdown": "# Overview\nContent...",
  "parentPageId": "..." // optional
}

🔧 Development

Project Structure

AIPRD/
├── Frontend/                 # React frontend application
│   ├── src/
│   │   ├── components/      # React components
│   │   ├── store/          # Zustand state management
│   │   ├── utils/          # Utility functions
│   │   ├── hooks/          # Custom React hooks
│   │   ├── i18n/           # Internationalization
│   │   └── types/          # TypeScript definitions
│   ├── public/             # Static assets
│   ├── vite.config.ts      # Vite configuration
│   └── package.json
│
├── server/                  # Express backend application
│   ├── src/
│   │   ├── models/         # MongoDB models
│   │   ├── routes/         # API route handlers
│   │   └── index.ts        # Express app entry
│   ├── .env.example        # Environment template
│   └── package.json
│
└── README.md               # This file

Development Workflow

Feature Branch: Create a branch from main

git checkout -b feature/your-feature-name

Make Changes: Implement your feature with tests
Code Quality: Run linters and formatters
```
npm run lint
npm run format
```
Testing: Ensure all tests pass
```
npm run test
```
Commit: Use conventional commits
```
git commit -m "feat: add new feature"
```

Push: Push your changes

git push origin feature/your-feature-name

Debugging

Frontend:

Use React DevTools browser extension
Zustand DevTools for state inspection
Vite's built-in error overlay

Backend:

Use console.log or debugger with tsx
MongoDB Compass for database inspection
Check logs in terminal for API errors

Performance Optimization

Frontend:

Code splitting with React lazy loading
Virtualized lists with react-window
AI response caching (1 min TTL)
Service worker for offline support

Backend:

Gzip compression for large JSON payloads
Rate limiting on sync endpoints
MongoDB indexing on frequently queried fields
Async job queue for long-running operations

🚢 Deployment

Frontend Deployment

Recommended Platforms:

Vercel (recommended for Vite apps)
Netlify
AWS Amplify
GitHub Pages

Vercel Example:

# Install Vercel CLI
npm i -g vercel

# Deploy
cd Frontend
vercel --prod

Build Command: npm run build
Output Directory: dist

Backend Deployment

Recommended Platforms:

Railway
Heroku
AWS Elastic Beanstalk
DigitalOcean App Platform
Render

Environment Variables: Ensure all required environment variables from .env.example are configured in your deployment platform.

Railway Example:

# Install Railway CLI
npm i -g @railway/cli

# Login and deploy
railway login
cd server
railway up

Database

MongoDB Options:

MongoDB Atlas (recommended for production)
Self-hosted MongoDB
DigitalOcean Managed MongoDB

MongoDB Atlas Setup:

Create a free cluster at mongodb.com/cloud/atlas
Whitelist your deployment platform's IP addresses
Update MONGODB_URI with connection string

Security Checklist

Set strong MONGODB_URI with authentication
Use environment variables for all secrets
Enable CORS only for trusted domains
Implement rate limiting in production
Use HTTPS for all connections
Rotate API keys regularly
Enable MongoDB encryption at rest
Set up monitoring and alerting

🤝 Contributing

We welcome contributions! Please follow these guidelines:

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Commit your changes: git commit -m 'feat: add amazing feature'
Push to the branch: git push origin feature/amazing-feature
Open a Pull Request

Commit Convention

We use Conventional Commits:

feat: New feature
fix: Bug fix
docs: Documentation changes
style: Code style changes (formatting, etc.)
refactor: Code refactoring
test: Adding or updating tests
chore: Maintenance tasks

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Google Gemini AI for powerful AI capabilities
Clerk for seamless authentication
MongoDB for flexible data storage
React and Vite for excellent developer experience
The open-source community for amazing tools and libraries

📞 Support

For questions and support:

Open an issue on GitHub Issues
Check existing documentation and README
Review closed issues for similar problems

🗺 Roadmap

Real-time collaboration with WebSockets
GitHub integration for issue sync
Advanced analytics and reporting
Mobile app (React Native)
AI-powered requirement conflict detection
Integration with Figma for design specs
Custom AI model training on organization data
Advanced RBAC (Role-Based Access Control)

Built with ❤️ by the AI PRD Team

⭐ Star this repo | 🐛 Report Bug | ✨ Request Feature

Name		Name	Last commit message	Last commit date
Latest commit History 12 Commits
Frontend		Frontend
server		server
README.md		README.md

Folders and files

Latest commit

History

Repository files navigation

🚀 AI-Powered PRD Builder

📋 Table of Contents

🎯 Overview

✨ Key Features

Frontend Features

Backend Features

🛠 Tech Stack

Frontend

Backend

🚀 Getting Started

Prerequisites

Installation

Configuration

Frontend Configuration

Backend Configuration

💻 Usage

Development Mode

Production Build

Testing

Code Quality

🏗 Architecture

System Overview

Frontend Architecture

Backend Architecture

📚 API Documentation

PRD Endpoints

GET /api/prds

POST /api/prds

PUT /api/prds/:id

DELETE /api/prds/:id

Snapshot Endpoints

GET /api/snapshots/:prdId

POST /api/snapshots

Sync Endpoints

POST /api/sync/linear

POST /api/sync/jira

GET /api/sync/jobs/:id

Notion Endpoints

POST /api/notion/page

🔧 Development

Project Structure

Development Workflow

Debugging

Performance Optimization

🚢 Deployment

Frontend Deployment

Backend Deployment

Database

Security Checklist

🤝 Contributing

Commit Convention

📄 License

🙏 Acknowledgments

📞 Support

🗺 Roadmap

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

`GET /api/prds`

`POST /api/prds`

`PUT /api/prds/:id`

`DELETE /api/prds/:id`

`GET /api/snapshots/:prdId`

`POST /api/snapshots`

`POST /api/sync/linear`

`POST /api/sync/jira`

`GET /api/sync/jobs/:id`

`POST /api/notion/page`