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:
- LinkedIn technical posts — Share what you built, not what you sell. Technical posts get 10x engagement.
- Dev.to / Hashnode articles — Technical credibility that ranks in Google.
- Upwork — Yes, seriously. Filter for $5K+ projects. My Upwork profile earns $2K-8K/month.
- Referrals — After your first 3 clients, this becomes your primary channel.
- 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.
Want to save 15+ hours of consulting work every week?
WEDGE Method AI is the AI operating system built for independent consultants.
→ Client research briefs in 8 minutes (vs 3 hours)
→ Proposals in 20 minutes (vs 4 hours)
→ Reports in 1 hour (vs a full day)
Top comments (1)
In my experience with gohighlevel consultant, the key is choosing tools that integrate well with your existing stack. Compatibility often matters more than features.