The Developer's Guide to AI Consulting: Pricing, Proposals, and Delivery

I've been doing AI consulting for the past year, charging $200-500/hour depending on the engagement. Most developers drastically undercharge because they don't know how to frame AI expertise as a business outcome. Here's my complete framework — with actual numbers, proposal structures, and delivery systems.

Why Developers Should Be AI Consultants Right Now

The market dynamics are exceptional:

• Supply/demand gap: Thousands of businesses want AI integration, but few developers can actually deliver it
• High perceived value: "AI" attached to anything commands premium pricing
• Low marginal cost: Your tools (Claude API, open-source models) cost pennies per use; clients pay for the architecture
• Recurring revenue: Every AI system needs monitoring, tuning, and expansion

Pricing Models: The Math That Works

Model 1: Hourly Consulting ($200-500/hr)

Best for: discovery calls, architecture reviews, audits.

# Pricing calculator for hourly consulting
from dataclasses import dataclass

@dataclass
class HourlyEngagement:
    hourly_rate: float
    hours_per_week: float
    weeks: int
    expenses: float = 0  # API costs, tools, etc.

    @property
    def gross_revenue(self) -> float:
        return self.hourly_rate * self.hours_per_week * self.weeks

    @property
    def effective_rate(self) -> float:
        """Rate after accounting for unbillable time (proposals, admin)."""
        billable_ratio = 0.65  # 65% of time is billable
        return self.hourly_rate * billable_ratio

    @property
    def net_revenue(self) -> float:
        return self.gross_revenue - self.expenses

    def __str__(self) -> str:
        return (
            f"Engagement: {self.weeks} weeks @ ${self.hourly_rate}/hr\n"
            f"Gross: ${self.gross_revenue:,.0f}\n"
            f"Net: ${self.net_revenue:,.0f}\n"
            f"Effective rate: ${self.effective_rate:,.0f}/hr"
        )

# Example: 10-hour/week engagement for 4 weeks
engagement = HourlyEngagement(
    hourly_rate=350,
    hours_per_week=10,
    weeks=4,
    expenses=200  # API costs
)
print(engagement)
# Engagement: 4 weeks @ $350/hr
# Gross: $14,000
# Net: $13,800
# Effective rate: $227/hr

Model 2: Project-Based ($5K-50K per project)

Best for: defined deliverables like chatbot builds, automation systems, AI integration.

@dataclass
class ProjectEngagement:
    project_name: str
    estimated_hours: int
    target_rate: float  # What you want per hour
    complexity_multiplier: float = 1.0  # 1.0-2.0 based on complexity
    rush_multiplier: float = 1.0  # 1.5 for rush jobs

    @property
    def base_price(self) -> float:
        return self.estimated_hours * self.target_rate

    @property
    def quoted_price(self) -> float:
        # Add 30% buffer for scope creep, round to nearest $500
        buffered = self.base_price * 1.3 * self.complexity_multiplier * self.rush_multiplier
        return round(buffered / 500) * 500

    @property
    def effective_hourly(self) -> float:
        """What you actually earn per hour if estimate is accurate."""
        return self.quoted_price / self.estimated_hours

# Example: AI chatbot for customer support
project = ProjectEngagement(
    project_name="AI Customer Support Chatbot",
    estimated_hours=60,
    target_rate=300,
    complexity_multiplier=1.2,  # Custom integrations
)
print(f"Quote: ${project.quoted_price:,.0f}")
print(f"Effective rate: ${project.effective_hourly:,.0f}/hr")
# Quote: $28,000
# Effective rate: $467/hr

Model 3: Retainer ($3K-10K/month)

Best for: ongoing AI system maintenance, monthly optimization, priority support.

@dataclass
class RetainerEngagement:
    monthly_fee: float
    included_hours: int
    overage_rate: float
    months: int = 12

    @property
    def annual_value(self) -> float:
        return self.monthly_fee * self.months

    @property
    def base_hourly(self) -> float:
        return self.monthly_fee / self.included_hours

    def monthly_invoice(self, actual_hours: float) -> float:
        overage = max(0, actual_hours - self.included_hours)
        return self.monthly_fee + (overage * self.overage_rate)

# Example: AI system maintenance retainer
retainer = RetainerEngagement(
    monthly_fee=5000,
    included_hours=15,
    overage_rate=400,
    months=12,
)
print(f"Annual value: ${retainer.annual_value:,.0f}")
print(f"Base rate: ${retainer.base_hourly:,.0f}/hr")
print(f"Month with 20hrs: ${retainer.monthly_invoice(20):,.0f}")
# Annual value: $60,000
# Base rate: $333/hr
# Month with 20hrs: $7,000

The Proposal Template That Converts

Every proposal I send follows this structure. It converts at roughly 40%:

from typing import Optional
from enum import Enum
from pydantic import BaseModel

class ProposalStatus(str, Enum):
    DRAFT = "draft"
    SENT = "sent"
    VIEWED = "viewed"
    ACCEPTED = "accepted"
    DECLINED = "declined"

class ProposalTemplate(BaseModel):
    client_name: str
    problem_statement: str  # Their pain in their words
    proposed_solution: str  # 2-3 paragraphs, technical but accessible
    deliverables: list[str]
    timeline_weeks: int
    investment: float
    roi_estimate: str  # "Save 20 hours/week = $X/year"
    payment_terms: str  # "50% upfront, 50% on delivery"
    valid_until: str
    status: ProposalStatus = ProposalStatus.DRAFT

    def to_markdown(self) -> str:
        deliverables_md = "\n".join(f"- {d}" for d in self.deliverables)
        return f"""# AI Implementation Proposal
## Prepared for {self.client_name}

### The Challenge
{self.problem_statement}

### Proposed Solution
{self.proposed_solution}

### Deliverables
{deliverables_md}

### Timeline
{self.timeline_weeks} weeks from project kickoff.

### Investment
**${self.investment:,.0f}** — {self.payment_terms}

### Expected ROI
{self.roi_estimate}

### Validity
This proposal is valid until {self.valid_until}.
"""

The Delivery Framework

How I actually deliver AI consulting projects:

Week 1: Discovery & Architecture
├── Stakeholder interviews (2-3 sessions)
├── Current system audit
├── Data pipeline assessment
└── Architecture document (deliverable #1)

Week 2-3: Build & Iterate
├── Core AI integration
├── API connections
├── Testing with real data
└── Weekly demo to client

Week 4: Deploy & Document
├── Production deployment
├── Monitoring setup
├── Documentation (deliverable #2)
├── Team training session (deliverable #3)
└── 30-day support window begins

Finding Clients: Where Developers Look

The highest-converting channels in my experience:

1. LinkedIn technical posts — Share what you built, not what you sell. Technical posts get 10x engagement.
2. Dev.to / Hashnode articles — Technical credibility that ranks in Google.
3. Upwork — Yes, seriously. Filter for $5K+ projects. My Upwork profile earns $2K-8K/month.
4. Referrals — After your first 3 clients, this becomes your primary channel.
5. AI tool directories — List your consulting practice on AI aggregator sites.

What Not To Do

• Don't charge hourly for everything. Project-based pricing captures more value.
• Don't skip the proposal. Written proposals convert 3x better than verbal agreements.
• Don't underestimate scope. Add 30-50% buffer to every estimate. Always.
• Don't work without a contract. Even for small projects. Especially for small projects.
• Don't compete on price. Compete on speed, expertise, and business outcomes.

I compiled my complete pricing framework — with 50+ proposal templates, contract language, and a client pipeline tracker — into the AI Consulting Pricing Bible. It's the system I actually use for every engagement.

---

What's your consulting rate and how did you arrive at it? Genuinely curious — pricing is the hardest part of consulting.