PromptRequest: From Hackathon Project to Full Platform

The evolution of PromptRequest - a prompting system that grew from hackathon entry to feature-complete platform for prompt engineering and management.

Some projects are built to solve today’s problem. Others evolve into something larger.

PromptRequest started as a hackathon entry. It became a full prompt engineering platform.

The Hackathon Origin

Challenge: Build something useful for AI developers in 48 hours.

Observation: Everyone was copy-pasting prompts from files, Notion pages, and random notes. There was no systematic way to:

• Store prompts centrally
• Version control changes
• Test prompt variations
• Share with teammates

Solution: Build a prompt management system.

Initial MVP

48-hour version had:

• SQLite database for prompt storage
• Basic CRUD operations
• Tags and categories
• Simple export/import

It wasn’t fancy, but it worked. And developers immediately wanted more.

What Users Asked For

After the hackathon, feedback poured in:

“I need to A/B test prompts”

Different versions produce different results. Users needed comparison tools.

“I want to share with my team”

Individual prompt libraries don’t scale. Teams needed collaboration.

“I need to track which version is in production”

When prompts are code, they need release management.

“I want templates, not just storage”

Dynamic prompts with variable substitution.

The Platform Evolution

Phase 1: Storage → Management

Added:

• Prompt versioning with diff view
• Environment tagging (dev, staging, prod)
• Access control per prompt
• Audit logging

Phase 2: Management → Testing

Added:

• Side-by-side comparison execution
• Metrics collection (latency, token usage)
• Quality scoring with human feedback
• Regression testing for prompt changes

Phase 3: Testing → Platform

Added:

• Team workspaces
• API access for programmatic use
• Integration with CI/CD pipelines
• Analytics dashboard

Technical Architecture

PromptRequest Architecture
├── Core Services
│   ├── Prompt Storage (PostgreSQL)
│   ├── Version Control (Git-like)
│   ├── Execution Engine
│   └── Analytics Pipeline
├── API Layer
│   ├── REST API
│   ├── GraphQL
│   └── SDK (TypeScript, Python)
├── Web Interface
│   ├── Editor with syntax highlighting
│   ├── Testing interface
│   └── Dashboard
└── Integrations
    ├── OpenAI / Anthropic / etc.
    ├── GitHub / GitLab
    └── Slack / Discord

Prompt Schema

interface Prompt {
  id: string;
  workspace: string;
  
  // Content
  name: string;
  description: string;
  template: string;  // With {{variable}} syntax
  
  // Metadata
  tags: string[];
  category: string;
  environment: 'dev' | 'staging' | 'prod';
  
  // Versioning
  version: number;
  parentVersion: number | null;
  changelog: string;
  
  // Default configuration
  model: string;
  temperature: number;
  maxTokens: number;
  
  // Tracking
  createdAt: Date;
  updatedAt: Date;
  createdBy: User;
  executionCount: number;
  lastExecuted: Date;
}

Template Engine

function renderPrompt(
  template: string, 
  variables: Record<string, string>
): string {
  // Replace variables
  let rendered = template;
  for (const [key, value] of Object.entries(variables)) {
    rendered = rendered.replace(
      new RegExp(`\\{\\{${key}\\}\\}`, 'g'),
      value
    );
  }
  
  // Validate all variables replaced
  const unreplaced = rendered.match(/\{\{[^}]+\}\}/g);
  if (unreplaced) {
    throw new Error(`Missing variables: ${unreplaced.join(', ')}`);
  }
  
  return rendered;
}

Key Features

1. Version Control

Full history of every prompt change:

• Who changed it
• What changed
• Why it changed
• When it was deployed

Roll back to any version with one click.

2. A/B Testing

Test prompt variations scientifically:

• Split traffic between versions
• Collect quality metrics
• Statistical significance calculation
• Winner deployment

3. Environment Management

Separate prompts by environment:

• Development: Experimental changes
• Staging: Testing before production
• Production: Deployed and stable

Promote between environments with review workflow.

4. API Access

from promptrequest import Client

client = Client(api_key="...")

# Get prompt
prompt = client.get_prompt("customer-support-v2")

# Execute with variables
response = client.execute(
    prompt_id="customer-support-v2",
    variables={"customer_name": "Alice", "issue": "billing"},
    model="claude-3-opus"
)

# Log feedback
client.log_feedback(
    execution_id=response.id,
    rating=5,
    notes="Perfect response"
)

5. Analytics Dashboard

Track across all prompts:

• Execution volume
• Average latency
• Token usage and cost
• Quality scores over time
• Error rates

Lessons Learned

1. Start Simple, Grow From Feedback

The 48-hour MVP validated the idea. User feedback directed every subsequent feature.

2. Prompts Are Code

Treat prompts with the same rigor as software:

• Version control
• Testing
• Review process
• Environment management

3. Collaboration Multiplies Value

Individual prompt libraries are useful. Team-shared libraries are transformative.

4. Metrics Enable Improvement

Without measurement, prompt changes are guesswork. With metrics, they’re engineering.

Growth Trajectory

What’s Next

Current roadmap:

• Prompt chains and workflows
• Multi-modal prompt support
• Automated optimization suggestions
• Enterprise SSO integration

PromptRequest demonstrates how hackathon projects can evolve into platforms. For related development tools, see MCP orchestration.