Prompt Playbook: Getting ready for revenue PART 4

Hey Prompt Entrepreneur,

Congratulations! People love your AI tool. Huzzah! You might have even gone viral. This is the genuinely the hardest part of starting a business - building something people are genuinely excited about.

But now they're using it. A lot. And your API bills are climbing. Gulp.

Each generation costs you money - maybe $0.005 for a simple text response, maybe $2 for a complex image creation tool. With success comes usage, and with usage comes costs.

Most people won't abuse your system, but we need basic protections in place. Better to have limits you don't need than bills you can't afford.

Let's get started:

Why Usage Limits Matter

Why did we wait until now to add limits and plans? Because it’s more complex. Remember we always build simple to complex. I wanted you to get your basic user accounts and billing in place before we add complications like tiered access. One thing at a time!

We’re now going to add usage limits. Ie. how much someone can use your AI tool.

This is a delicate balance between pricing, usage limits, subscriptions vs one-off payments - it's multivariate and complex. Ultimately, you'll need to experiment: set a price, set a usage limit, see if people stay subscribed and don't churn (cancel their subscription)!

Working Out Your Usage Limits

Usage limits depend entirely on what your tool does. I can’t just give you an answer unfortunately!

Maybe your tool creates dream diary picture books using expensive image generation - each session might cost you $2 in API fees.

Or maybe it's text-based with simple responses - each request costs $0.005.

You need to gauge how much each "complete usage" costs you - from start to finish of one session.

How to test this:

1. Go into your AI tool and use it 10 times, varying your inputs

2. Check your OpenAI API usage dashboard

3. Note the total cost and divide by 10

4. That's your average cost per usage

Pretty rough but it gets you in the ballpark. And once you have this data, you can set intelligent limits.

Calculate Your Usage Limits

Let’s use a prompt to help us work out our limits.

Help me calculate usage limits for my AI tool subscription:

My tool details. First ask me for:
- Average cost per complete usage session: $[your tested amount]
- Monthly subscription price: $[your chosen price]

Calculate and suggest:

GENEROUS LIMITS (70% profit margin):
- Maximum monthly usage to maintain profitability
- Recommended limit with buffer for variation
- What this means for typical user experience

NORMAL LIMITS (85% profit margin):
- Conservative usage limits for healthy margins
- Recommended for most AI tools
- Balance of value and profitability

STRICT LIMITS (95% profit margin):
- Very conservative limits maximising profit
- Risk of customer dissatisfaction
- Only if your tool provides extremely high value

POWER USER TIER:
- Higher usage limit for premium pricing
- Suggested price point for heavy users
- What usage level justifies the higher cost

For each tier, explain:
- Monthly usage limit
- Cost breakdown
- Profit per customer
- Risk assessment

Base calculations on real API costs, not theoretical numbers. Use Python or a similar tool for calculations. 

Make sure that your AI uses the current API costs. It should be able to go and fetch them for you. If not just copy and paste them in from the ChatGPT pricing page.

Your Usage Tier Strategy

Once you know your limits, we can design your tiers. This is optional but will help i) get in paid customers and ii) deal with high usage power users.

Here’s an example of what it might look like.

Free Tier (Lead Generation):

• 3-5 uses to prove value and collect email addresses

• Clear upgrade prompts when exhausted

• No credit card required to test then prompted for payment after 3-5 uses

• Primary goal: get people to experience the value and pay

Paid Tier (Your Main Business):

• Usage limit based on your calculations above

• Monthly reset on billing anniversary

• This is where you make your money - the core business and what we’ve been designing the last few days

Power User Tier (Future Revenue):

• For the 5-10% who burn through regular limits

• Higher usage allowance at premium price

• Add this once you see people consistently hitting limits

You’ll probably just start with just Free + Paid. Add Power User tier once you understand actual usage patterns and have customers requesting more capacity.

Adding Usage Tracking to Your Tool

OK let’s implement this all! First we need a way to keep track of what’s been used by what user. Your Supabase database needs to track usage. Here’s a prompt to plug into Lovable:

I need to add a credit system to track AI usage in my app with Supabase:

Database schema needed:
1. Add to user profiles table:
   - account_type (free/paid/cancelled)
   - credits_remaining (integer, default based on tier)
   - credits_used_this_month (integer, default 0)
   - last_credit_reset (timestamp)
   - subscription_start_date (timestamp)

2. Create usage_log table:
   - user_id (foreign key to profiles)
   - credits_used (integer)
   - action_type (text: "ai_generation", "api_call", etc)
   - timestamp (when the usage occurred)

Credit rules:
- Free users: 5 credits total, no reset
- Paid users: [INSERT YOUR CALCULATED LIMIT] credits, reset monthly on subscription anniversary
- Each AI request costs 1 credit
- Block requests when credits_remaining = 0
- Show usage dashboard with remaining/used counts

Please create this database structure and the logic to handle credit deduction and monthly resets.

Make sure to insert your calculated limit from before! And I’ve set the free tier usage to 5 credits here but obviously adjust as necessary.

Credit Control Integration

Next up we need some logic that puts this into play whenever a user request comes in. Basically your AI tool needs to check credits before processing requests. Again use this prompt in Lovable:

Add credit checking and deduction to my AI tool:

Before any AI API call:
1. Check user's credits_remaining
2. If credits_remaining > 0: proceed with AI request
3. If credits_remaining = 0: show upgrade message, block request

After successful AI response:
1. Deduct 1 from credits_remaining  
2. Add 1 to credits_used_this_month
3. Update user interface with new credit count

Error handling:
- If AI API call fails, don't deduct credits
- If user has 0 credits, show clear upgrade path
- If database update fails, log error but don't break user experience

UI requirements:
- Show credits remaining prominently in interface
- Clear upgrade button when approaching limits
- What they get when they upgrade

Please implement this credit checking and deduction system.

From here make sure to test it out extensively. Again, ask your champions for assistance if you need to! Reward them with extra credits (ask Lovable to create you a “gift credit” function in the backend - you’re a vibe coder now!) if necessary.

Your Deliverable Today

By end of day:

• Tested your tool to understand actual API costs per usage

• Calculated appropriate usage limits using the AI prompt

• Added credit tracking to your database schema

• Implemented credit deduction logic in your AI tool

• Clear upgrade messaging when limits are reached

Build in Public Content

Share your usage control implementation:

"Day 34 of AI Summer Camp: Added usage limits to my AI tool.

Tested 10 real uses: average cost $0.013 per generation. At $39/month, setting limit of 200 uses = healthy 85% margins.

Free users get 5 tries to prove value. Most people won't hit limits, but I need protection from the few who would.”

What's Next?

Tomorrow we focus on customer onboarding and success. You've got the payment and usage systems working - now we make sure new customers understand how to get value from your tool immediately. Your business infrastructure is nearly complete. Time to focus on customer experience and make some revenue.

Keep Prompting,

Kyle

If you feel this — learning how to use AI in entrepreneurship and work — is not for you → Unsubscribe here.