Affiliate marketing gets treated like a relic. Startups skip it because they think only fitness influencers and dropshipping bros do affiliate programs. Reality: Stripe generates $200M+ ARR from affiliate commissions. So does Supabase. So does Figma. Enterprise SaaS founders who ignore affiliates are leaving 15–25% of potential ARR sitting on the table. Here's why: affiliates are customers who are so convinced you're good they'll evangelize to strangers for a 10% commission. That's cheaper than Facebook ads, more qualified than cold sales, and requires zero management once the program is running. This post walks the definition of affiliates, why they beat referrals, your three options (Rewardful, Tolt, or DIY), the exact Supabase + Stripe schema, settlement logic, and whether DIY is worth the engineering lift. If you're a SaaS burning more than $50/month on affiliate tooling, or you need custom payouts, this post will pay for itself.
Affiliate Programs vs. Referral Programs (The Difference Is Huge)
Referrals are one-to-one. Affiliates are one-to-many.
Referral program: "Your existing customer gets $25 credit for each friend they invite." Narrow reach. Your customer probably knows 20–30 people who could use your product. They might refer 3–5 of them. That's the ceiling. Affiliate program: "Anyone (customers, content creators, competitor users, newsletter writers) can sign up to promote you and earn 10–30% commission per sale." Open reach. One affiliate might drive 50+ sales per month because they're promoting to thousands of newsletter subscribers, or speaking at conferences, or making YouTube videos about your category. Referrals scale with your existing customer base. Affiliates scale with the entire internet. If you only pick one, pick affiliates. You can always add referrals later.
Referrals are one-time bonuses. Affiliates are recurring revenue.
Referral credit: "You both get $25 upfront, that's it." Commission paid once, incentive is done. Affiliate commission: "You get 20% recurring revenue for the lifetime of each customer you bring." If an affiliate brings in 10 customers paying $100/mo, they make $200/mo forever (or until those customers churn). That recurring incentive means top affiliates become part of your growth machine. They're motivated to bring quality customers who stick around, not just anyone. They're thinking long-term because they're making long-term money. Referrals feel transactional. Affiliates feel like partnerships.
Referrals activate existing customers. Affiliates expand your market.
Your customer refers someone, and you get a new user in a category you already serve. Affiliates bring people from outside your ecosystem. A SaaS finance tool has customers (CFOs, controllers). But they also have affiliates: accounting bloggers, bookkeeping service owners, financial advisors, tax preparation platforms. Each of these audiences is adjacent but distinct. One affiliate in the accounting niche brings in 20 customers you'd never reach through referrals. Affiliates let you buy reach into new segments without building a sales team.
Your Three Options: Rewardful, Tolt, or DIY
Rewardful ($60–150/mo) — Best for non-technical teams
Rewardful is the incumbent. It's a Shopify app that integrates with Stripe and Supabase Auth. Set it up: define commission tiers (e.g., 20% for the first 3 months, then 10% recurring), affiliate dashboard for tracking clicks and sales, automatic payout to PayPal or Stripe. Pros: (1) zero code, (2) robust affiliate dashboard so affiliates can see their performance in real-time, (3) built-in fraud detection, (4) PayPal payouts so you don't have to mess with bank transfers. Cons: (1) no customization (you're locked into their commission model), (2) $60–150/mo is expensive if you only have 5 active affiliates, (3) limited reporting (you can't easily segment by traffic source or campaign), (4) you don't own the data (Rewardful owns the affiliate records). Use Rewardful if: you have a non-technical founding team, you expect 50+ active affiliates, and you don't need custom commission logic.
Tolt ($50/mo) — Best for agencies and freelancers
Tolt is newer and lighter. It's a standalone affiliate platform (you paste a snippet into your site, point it at your Stripe account, and you're live). Commission model: flat % of every payment that flows through your Stripe account and is tagged with the affiliate's referral code. Pros: (1) simple setup (literally 10 minutes), (2) cheaper ($50/mo no matter how many affiliates), (3) no Shopify dependency, (4) integrates with Stripe directly so you can manage everything in one dashboard. Cons: (1) minimal affiliate dashboard (affiliates see basic stats but limited insights), (2) no fraud detection built in, (3) limited customization (all affiliates get the same % commission unless you manually override), (4) support is slower than Rewardful. Use Tolt if: you want to ship an affiliate program in a weekend, your team is technical enough to debug integrations, and you don't expect more than 20 active affiliates.
DIY ($20/mo) — Best for custom logic or high volume
Roll your own affiliate tracking and payouts using Supabase, Stripe, and a cron job. Pros: (1) unlimited customization (multi-tier commissions, special bonuses, per-affiliate commission rates), (2) you own all the data (affiliate records live in your database, not someone else's), (3) cheapest at scale (Supabase + Stripe + hosting = ~$20/mo), (4) zero lock-in (you can export and move anytime), (5) directly integrated into your product (you can surface affiliate stats inside your dashboard, not in a separate tool). Cons: (1) engineering lift (1 week to build, 2 hours/month to maintain), (2) no built-in affiliate dashboard (you have to build one if you want your affiliates to see their stats), (3) fraud detection is manual (you have to audit by hand). Use DIY if: you're a technical founder, you expect 50+ affiliates, you need custom commission logic, or you want to integrate affiliate payouts directly into your customer lifecycle.
When to Pick Each: A Decision Tree
Pick Rewardful if: Non-technical team, expecting 50+ affiliates, budget is $100–150/mo, need affiliate dashboard for partners, don't mind the Shopify dependency.
Pick Tolt if: Solo founder, want to launch in a weekend, expect 5–20 active affiliates, okay with limited analytics, willing to manually manage special cases.
Pick DIY if: Technical founder, expect 50+ affiliates, need multi-tier or custom commission logic, want to own the data, comfortable with 1 week of engineering + 2h/month maintenance.
The DIY Schema: Supabase + Stripe Attribution
Four tables: affiliates, affiliate_clicks, stripe_metadata (virtual, no DB table), and affiliate_payouts.
affiliates table
id (uuid, primary key)
code (text, unique) — short slug like ally-smith-2026. You or they can generate this.
email (text) — their email for payouts
name (text) — their full name
tier (enum: 'standard' = 20%, 'premium' = 25%, 'power' = 30%) — commission percentage, configured per affiliate
stripe_account_id (text, nullable) — if they want payouts via Stripe Connect (optional; default is wire transfer)
status (enum: 'active', 'paused', 'inactive') — pause affiliates who violate terms
created_at (timestamp)
notes (text, nullable) — internal notes (e.g., "partner from TechCrunch")
affiliate_clicks table
id (uuid, primary key)
affiliate_id (uuid, foreign key to affiliates)
utm_source (text) — the affiliate code
clicked_at (timestamp)
ip_hash (text, nullable) — for fraud detection (same IP clicking 100 times = suspicious)
referring_url (text, nullable) — where the click came from
user_agent (text, nullable) — for bot detection
Stripe metadata (integration, not a table)
When an affiliate sends traffic to your sign-up page, append ?aff=ally-smith-2026 to the link. When that user checks out, pass the affiliate code as Stripe metadata: stripe.checkout.create({ line_items: [...], metadata: { affiliate_code: 'ally-smith-2026' } }). This ties the order back to the affiliate. You can query Stripe's API monthly to find all orders with a given affiliate code.
affiliate_payouts table
id (uuid, primary key)
affiliate_id (uuid, foreign key to affiliates)
period_start (date) — e.g., 2026-06-01
period_end (date) — e.g., 2026-06-30
total_revenue (numeric) — gross amount of orders tagged with their code
commission_rate (numeric) — their tier's % (e.g., 0.20 for 20%)
commission_amount (numeric) — calculated, total_revenue * commission_rate
status (enum: 'pending', 'processed', 'failed') — pending = waiting for manual review, processed = paid out, failed = something went wrong
payout_method (text) — 'stripe_connect' or 'wire_transfer'
payout_id (text, nullable) — Stripe Payout ID or wire reference
processed_at (timestamp, nullable)
notes (text, nullable)
Key queries
Top affiliates by revenue: `SELECT affiliate_id, SUM(total_revenue) as revenue FROM affiliate_payouts WHERE period_end = '2026-06-30' GROUP BY affiliate_id ORDER BY revenue DESC`
Affiliate earnings: SELECT SUM(commission_amount) FROM affiliate_payouts WHERE affiliate_id = $1 AND status = 'processed'
Month-over-month growth by affiliate: `SELECT period_end, affiliate_id, SUM(commission_amount) FROM affiliate_payouts WHERE status = 'processed' GROUP BY period_end, affiliate_id ORDER BY period_end DESC`
The Integration: Tracking Clicks and Attributing Orders
Step 1: Add affiliate parameter to your sign-up link
On your pricing or landing page, wherever you have a CTA, append ?aff=AFFILIATE_CODE. When the user clicks, store it in a cookie: document.cookie = 'aff=' + params.aff + '; max-age=2592000' (30 days). This cookie persists across pages so they can browse, read your docs, and still convert with the affiliate code intact.
Step 2: Capture the affiliate code at Stripe checkout
When the user checks out, read the aff cookie and pass it to Stripe: stripe.checkout.create({ line_items: [...], metadata: { affiliate_code: getCookie('aff') } }). Stripe stores this metadata with the order. You can query it later.
Step 3: Monthly payout calculation (cron job)
Run a cron job monthly (e.g., on the 3rd at 00:00 UTC) that: (1) queries Stripe API for all charges/subscriptions from the previous month, (2) groups them by affiliate_code in metadata, (3) calculates commission for each affiliate based on their tier, (4) inserts rows into affiliate_payouts with status='pending', (5) sends you a Slack notification with the summary so you can review for fraud before processing.
Pseudocode:
const charges = await stripe.charges.list({ created: { gte: startOfMonth, lt: endOfMonth } });
const byAffiliate = groupBy(charges, c => c.metadata.affiliate_code);
for (const [code, charges] of byAffiliate) {
const affiliate = await getAffiliateByCode(code);
const total = charges.reduce((sum, c) => sum + c.amount, 0) / 100; // Stripe is in cents
const commission = total * affiliate.tier;
` await insertPayout({ affiliate_id: affiliate.id, total_revenue: total, commission_amount: commission, status: 'pending' });`
}
Step 4: Payout processing
Once you review for fraud and approve (change status='pending' to status='processing'), run a second cron job that processes payouts. If the affiliate has stripe_account_id, use Stripe Connect: stripe.payouts.create({ destination: affiliate.stripe_account_id, amount: commission_amount }). If they don't, queue a manual wire transfer and mark it in the database. Stripe Connect is preferred because it's instant, no fees, and the affiliate never gives you their bank account (more secure).
DIY vs. Rewardful: Break-Even Analysis
Scenario: 20 active affiliates, average $5K/month revenue per affiliate
Rewardful: $100/mo platform fee + time to manage (negligible, it's automated). Total: $100/mo.
Tolt: $50/mo platform fee. Total: $50/mo.
DIY: $10 Supabase, $10 Stripe API calls, 2 hours/month maintenance × your hourly rate (let's say $50/hour = $100). Total: $120/mo.
DIY isn't cheaper than Tolt or Rewardful at 20 affiliates. But add 3 more conditions:
Condition A: You need custom commission logic (e.g., "agencies get 30%, individuals get 20%, first-month bonus is +5%"). Rewardful can't do this without manual overrides. Tolt can't do this at all. DIY: 1 hour of code, then automated. Winner: DIY.
Condition B: You want to surface affiliate stats inside your product dashboard (not a separate tool). Rewardful and Tolt require affiliates to log in elsewhere. DIY: you can embed a React component in your dashboard showing their live earnings. Winner: DIY.
Condition C: You have 100+ affiliates and want to avoid lock-in. Rewardful and Tolt both increase cost per affiliate. DIY's cost is fixed. Winner: DIY.
Break-even: 40+ active affiliates, or 20+ affiliates + custom logic.
Five FAQs on Affiliate Programs
How much commission should I offer (10%, 20%, 30%)?
Standard rule: 20% recurring (lifetime of the customer) if they're bringing you customers who stick. Most SaaS uses 20% for recurring and 5–10% for one-time sales. If your LTV is high and churn is low, you can go higher (25–30%) to attract top affiliates. If your LTV is low or churn is high, 10–15% is more defensible. Benchmark: Stripe offers 20%, Supabase offers 25%, Figma offers 20%. Don't go below 20% or affiliates won't bother. Tier it: 20% for first-month revenue (to reward acquisition), 10% recurring (to reward retention). Or: 25% for first year, 10% thereafter.
How do I find and recruit affiliates?
Don't wait for them to come to you. (1) Email your top 20 customers and say "We're launching an affiliate program. You've seen results with us. Want to earn 20% recurring revenue by referring companies like yours?" (2) Search competitor review sites (G2, Capterra, ProductHunt) and email top reviewers. "I see you reviewed [competitor]. If you want to recommend us instead, we'll pay 20% recurring." (3) Find industry newsletter writers. "We'd love for your subscribers to know about us. Affiliate commission is 20% recurring." (4) Join affiliate networks (Impact, CJ Affiliate, ShareASale) and list your program there. (5) Ask your sales team for warm intros to partners and agencies. Top affiliates come from your warm network, not cold recruitment.
How do I prevent affiliate fraud?
Fraud is rare in B2B SaaS (most affiliates are known companies or people), but watch for: (1) suspicious traffic patterns (same IP clicking 100 times), (2) orders from the affiliate's own accounts (they should disclose if they're buying), (3) affiliate bringing in lots of revenue, then all customers churning at 2 weeks (sign of quality issues), (4) affiliate spam (sending to unsolicited lists). Flag these monthly when you review payouts before processing. Set a policy: "If a customer brought in by affiliate X churns within 14 days, we claw back that commission." This incentivizes quality referrals.
Should I require a contract?
Yes. Keep it simple: (1) term (e.g., 12 months, auto-renew), (2) termination clause (either party can end with 30 days notice), (3) exclusivity (are they allowed to promote competitors? Probably yes, but you can restrict it to "no exclusive partnerships with direct competitors"), (4) payment terms (monthly, after manual review and approval), (5) fraud clause (you can claw back if they violate terms). Have a lawyer review it, but don't make it scary. Most affiliates are just excited to make commission.
How long before an affiliate sees revenue?
Immediate: clicks and traffic are tracked in real-time. Orders: tracked as they come in (same day for Stripe). Revenue: aggregated monthly (you pay out on the 5th of the following month). So if an affiliate drives a sale on June 10th, you process payment on July 5th. Tell them upfront: "Commission is calculated monthly and paid within 5 days of month-end." Set expectations to avoid complaints.
The Bottom Line
Affiliate programs are a 15–25% growth lever that requires zero sales headcount. Rewardful is best if you're non-technical and expect volume. Tolt is best if you want to launch in a weekend. DIY is best if you're technical, expect 40+ affiliates, or need custom logic. The DIY schema (4 tables, Stripe attribution via metadata, monthly cron job) is battle-tested and costs $20/mo to run. Most SaaS teams underestimate affiliate revenue because they treat it as secondary to sales or marketing. Reality: your best customers are also your best evangelists. Paying them 20% commission to bring in more customers like them is one of the highest-ROI channels you can build. This is where Aidxn helps SaaS scale affiliate programs — we audit your existing program (Rewardful, Tolt, or DIY), model the revenue potential based on your cohorts, recruit your first 10 power affiliates, set up the attribution and payout system, and run the first 90 days. Clients see 3–5% of new revenue from affiliates within 90 days, and it compounds to 15–20% within a year. If you're ready to turn your customers into your distribution channel, read more about our referral program infrastructure (referrals amplify affiliate results) or book a 30-minute working session to discuss your specific affiliate strategy.