Monetizing Side Projects with Tiered Affiliates + Books

Let me tell you what nobody at those "passive income" conferences wants to admit: most side projects don't make money. They make traffic. They make GitHub stars. They make interesting conversation at meetups. But actual revenue? The kind that pays for heating oil and satellite internet in Alaska? That requires a monetization strategy that goes beyond slapping an AdSense banner on your sidebar and hoping for the best.

I've spent the last year building a monetization system across my projects that combines tiered affiliate partnerships with book sales, and it's the first approach that's generated consistent, meaningful income without making me feel like a used car salesman. It's not going to make me rich. But it covers my infrastructure costs with room to spare, and it scales with content rather than requiring constant manual effort.

Here's exactly how it works, what the numbers look like, and where I screwed up along the way.

---

The Problem with Single-Channel Monetization

When I first started monetizing Grizzly Peak Software, I did what every developer blogger does: I signed up for Amazon Associates and dropped affiliate links into my articles whenever I mentioned a book or a piece of hardware. The conversion rates were terrible. Like, embarrassingly terrible.

The math was simple and depressing. My articles were getting around 5,000 page views per month. Amazon Associates pays between 1% and 4.5% commission depending on the category. Technical books run about $40 to $50. Even at a generous 3% click-through rate and 10% conversion rate on clicks, we're talking:

5,000 views x 3% click-through = 150 clicks
150 clicks x 10% conversion = 15 sales
15 sales x $45 average x 4.5% commission = $30.37/month

Thirty bucks a month. That doesn't even cover my DigitalOcean hosting bill. And those click-through and conversion estimates were optimistic — the reality was closer to $15 to $20 per month.

Single-channel monetization fails for side projects because the traffic volumes are too low to make any single channel profitable. You need to stack multiple revenue streams, each capturing a different segment of your audience at a different price point.

---

The Tiered Model

The approach I landed on has three tiers, and each tier serves a different audience segment with a different willingness to pay.

Tier 1: Context-Relevant Affiliate Links (Low Intent) These are the standard affiliate links, but placed strategically within content where the reader is already thinking about purchasing something. Not random sidebar ads — actual recommendations woven into articles where they make sense.

Tier 2: Curated Resource Pages with Multiple Affiliate Programs (Medium Intent) Dedicated pages that aggregate tools, services, and resources around specific topics. These target readers who are actively researching a purchase decision.

Tier 3: Self-Published Books and Digital Products (High Intent) Original content products that capture the highest-value segment — people who want comprehensive, structured knowledge and are willing to pay a premium for it.

The key insight is that these tiers work together. An article brings someone in at Tier 1. If they're interested enough, they explore resource pages at Tier 2. If they want to go deep, they buy a book at Tier 3. Each tier filters for higher intent and higher value.

// Simplified model of the tiered funnel
var monetizationTiers = {
    tier1: {
        type: 'contextual_affiliates',
        avgCommission: 3.50,
        conversionRate: 0.008,
        trafficShare: 1.0      // 100% of traffic sees these
    },
    tier2: {
        type: 'resource_pages',
        avgCommission: 15.00,
        conversionRate: 0.035,
        trafficShare: 0.12     // ~12% navigate to resource pages
    },
    tier3: {
        type: 'books_and_products',
        avgCommission: 8.50,   // net after platform fees
        conversionRate: 0.02,
        trafficShare: 0.05     // ~5% reach book pages
    }
};

function estimateMonthlyRevenue(monthlyPageViews) {
    var total = 0;

    Object.keys(monetizationTiers).forEach(function(tier) {
        var t = monetizationTiers[tier];
        var tierTraffic = monthlyPageViews * t.trafficShare;
        var tierRevenue = tierTraffic * t.conversionRate * t.avgCommission;
        total += tierRevenue;
        console.log(tier + ': $' + tierRevenue.toFixed(2) + ' (' + Math.round(tierTraffic) + ' visitors)');
    });

    return total;
}

// At 10,000 monthly page views:
// tier1: $280.00 (10000 visitors)
// tier2: $630.00 (1200 visitors)
// tier3: $85.00 (500 visitors)
// Total: ~$995/month

Those numbers are idealized, but they illustrate the principle: Tier 2 generates the most revenue despite reaching the fewest people, because the intent is higher and the commissions are larger.

---

Tier 1: Making Affiliate Links Actually Work

Here's what I learned about affiliate links after a year of experimenting: placement matters more than volume. Dropping ten Amazon links into an article doesn't convert ten times better than dropping in two. In fact, it converts worse, because it feels spammy and erodes trust.

The links that actually convert share three characteristics:

1. They appear at the exact moment the reader is thinking about the product
2. They include a genuine personal recommendation, not just "check out this book"
3. They're clearly marked as affiliate links (transparency builds trust, not destroys it)

Here's how I handle affiliate links in my article rendering.

var showdown = require('showdown');

// Custom Showdown extension for affiliate links
var affiliateExtension = function() {
    return [{
        type: 'lang',
        regex: /\[affiliate:(.+?)\]\((.+?)\)/g,
        replace: function(match, text, url) {
            var taggedUrl = appendAffiliateTag(url);
            return '<a href="' + taggedUrl + '" target="_blank" rel="noopener noreferrer sponsored" class="affiliate-link">' +
                   text + '</a>' +
                   '<span class="affiliate-disclosure"> (affiliate link)</span>';
        }
    }];
};

function appendAffiliateTag(url) {
    if (url.indexOf('amazon.com') !== -1) {
        var separator = url.indexOf('?') !== -1 ? '&' : '?';
        return url + separator + 'tag=' + process.env.AMAZON_DEFAULT_TAG;
    }
    return url;
}

I also diversified beyond Amazon. Amazon Associates is the obvious starting point, but their commissions are low and they have a habit of cutting rates with no warning. I added affiliate relationships with:

• DigitalOcean (hosting referrals — $200 credit for new users, $25 for me)
• Anthropic / OpenAI (API credit referrals for AI-focused articles)
• Udemy / Coursera (course recommendations — 10-15% commission)
• Specific SaaS tools I actually use (Contentful, MongoDB Atlas, etc.)

The key is that I only promote things I genuinely use. My DigitalOcean referrals convert well because my readers can see that my actual production infrastructure runs on DigitalOcean. When I recommend a book about API design, it's because I've read it and it changed how I think about the problem. Authenticity isn't a marketing tactic — it's the only sustainable approach.

---

Tier 2: Resource Pages as Revenue Engines

This was the breakthrough that changed my monetization math. Resource pages are dedicated, SEO-optimized pages that aggregate the best tools and resources around a specific topic. Think "Best Tools for Solo Developers in 2026" or "Essential Books for API Development."

These pages work for three reasons.

First, they attract high-intent search traffic. Someone Googling "best Node.js hosting 2026" is much closer to a purchasing decision than someone reading a tutorial about Express middleware. The search intent is commercial, not informational.

Second, they allow for higher-commission affiliate programs. Instead of linking to a $45 book with a 4.5% commission, I'm linking to SaaS products with monthly subscriptions and 20-30% recurring commissions. One DigitalOcean referral that sticks for a year is worth more than fifty book sales.

Third, they compound over time. A well-written resource page can rank in Google for months or years, generating traffic and commissions long after I've written it. My "best hosting for Node.js" page has been live for four months and generates about $180 per month consistently.

// Resource page data structure
var resourcePage = {
    slug: 'best-nodejs-hosting-2026',
    title: 'Best Node.js Hosting Platforms in 2026',
    lastUpdated: '2026-02-15',
    resources: [
        {
            name: 'DigitalOcean App Platform',
            category: 'PaaS',
            description: 'What I use for grizzlypeaksoftware.com. Simple deployment from GitHub.',
            affiliateUrl: 'https://m.do.co/c/referral-code',
            commission: { type: 'credit', amount: 25.00 },
            personalExperience: true,
            rating: 4.5
        },
        {
            name: 'Railway',
            category: 'PaaS',
            description: 'Great for hobby projects. Generous free tier.',
            affiliateUrl: 'https://railway.app?ref=grizzlypeak',
            commission: { type: 'percentage', amount: 0.25 },
            personalExperience: true,
            rating: 4.0
        }
        // ... more resources
    ]
};

One thing I got wrong initially: I tried to include every possible option on each resource page. Twenty hosting providers, fifteen database tools, ten monitoring services. The pages were comprehensive but overwhelming. Readers would bounce because there were too many choices.

I cut each page down to five to seven recommendations max, ranked by my genuine preference. Fewer choices, stronger opinions, better conversions. People don't want a catalog. They want someone they trust to say, "I've tried a bunch of these, and here's what I'd pick."

---

Tier 3: Books as the Highest-Value Tier

This is where things get interesting and where most developers leave money on the table. Self-published technical books are one of the best monetization strategies for a developer with domain expertise, and almost nobody does it because they think writing a book is too hard.

It is hard. I won't pretend otherwise. My book on training large language models took four months of focused work. But here's what makes books special as a monetization channel:

1. High perceived value. A blog post is free. A book is $25 to $40. People assign more credibility and more value to the same information when it's packaged as a book.
2. You keep most of the revenue. Amazon KDP pays 70% royalty on ebooks priced between $2.99 and $9.99, and 60% on print books. Compare that to 4.5% on affiliate commissions.
3. Books build authority. Being a published author changes how people perceive you. It opens doors for consulting, speaking, and partnerships. The book itself is a marketing asset.
4. Long tail revenue. My book still sells five to ten copies per month with zero ongoing marketing. It's not life-changing income, but it's consistent.

Here's the integration point that makes books work within the tiered model: every article I write is a potential gateway to the book. Not in a pushy way — I don't end every article with "BUY MY BOOK." Instead, I mention it naturally when it's relevant.

// Book promotion - randomly select from available books
function getBookPromotion(articleCategory) {
    var books = [
        {
            title: 'Training LLMs: A Practical Guide',
            categories: ['AI', 'Machine Learning', 'LLM'],
            url: '/books/training-llms',
            coverImage: '/images/books/training-llms-cover.png',
            tagline: 'From data preparation to fine-tuning — everything I learned building production AI systems.'
        }
    ];

    var relevant = books.filter(function(book) {
        return book.categories.some(function(cat) {
            return cat.toLowerCase() === articleCategory.toLowerCase();
        });
    });

    if (relevant.length === 0) return null;
    return relevant[Math.floor(Math.random() * relevant.length)];
}

I rotate book promotions on article pages — a small card in the sidebar that shows up on relevant articles. It's not intrusive. It doesn't interrupt the reading experience. But it consistently drives three to five sales per week, which at an $8.50 net per sale adds up to $100 to $170 per month.

---

The Numbers: What This Actually Looks Like

I promised honesty, so here are my real numbers from last month across all three tiers.

Tier 1 — Contextual Affiliate Links:

• Amazon Associates: $47.82
• DigitalOcean referrals: $75.00 (3 signups)
• Other affiliates: $22.15
• Subtotal: $144.97

Tier 2 — Resource Pages:

• Hosting comparison page: $185.00
• Developer tools page: $62.30
• Book recommendations page: $38.50
• Subtotal: $285.80

Tier 3 — Books:

• Ebook sales: $93.50
• Print sales: $68.00
• Subtotal: $161.50

Total: $592.27

Is that going to replace a six-figure engineering salary? Obviously not. But consider the context: this revenue comes from content I've already written, running on infrastructure that costs me about $45 per month. My marginal cost for each additional dollar of revenue is essentially zero. And it grows as my content library grows. Every new article I publish is another entry point into the funnel.

Six months ago, before I implemented the tiered model, I was making about $60 per month. Same traffic, roughly the same content. The difference is entirely structural — how the monetization is organized, not how much I'm promoting it.

---

Mistakes I Made (So You Don't Have To)

Mistake 1: Promoting products I hadn't used. Early on, I included some affiliate recommendations based purely on commission rates rather than personal experience. A reader called me out on it in a comment, and they were right. I removed every recommendation I couldn't personally vouch for, and paradoxically, my conversion rates went up. Trust is worth more than a higher commission percentage.

Mistake 2: Not disclosing affiliate relationships clearly. I initially used tiny disclaimer text at the bottom of articles. Then I read the FTC guidelines more carefully and realized I needed to be more explicit. Now every affiliate link is marked inline, and every page with affiliate content has a clear disclosure at the top. This isn't just legal compliance — it's respect for your readers.

// Middleware to add affiliate disclosure to pages with affiliate content
function affiliateDisclosure(req, res, next) {
    var originalRender = res.render;

    res.render = function(view, options) {
        if (options && options.hasAffiliateLinks) {
            options.affiliateDisclosure = 'This page contains affiliate links. ' +
                'If you purchase through these links, I may earn a commission ' +
                'at no additional cost to you. I only recommend products I personally use.';
        }
        originalRender.call(res, view, options);
    };

    next();
}

Mistake 3: Ignoring Amazon's attribution window. Amazon Associates gives you a 24-hour cookie window. That means if someone clicks your link but doesn't buy until tomorrow, you don't get the commission. For high-consideration purchases like expensive technical books, this is brutal. I started writing content that targets impulse-friendly products (under $30, immediately useful) and saw better conversion rates. The $65 textbook recommendation sounds more impressive, but the $15 pocket reference actually sells.

Mistake 4: Not tracking which content drives which revenue. For the first three months, I had no idea which articles were generating affiliate income and which were dead weight. I finally built a simple tracking system that tags affiliate clicks with the source article, and the data was eye-opening. Three articles generated 60% of my affiliate revenue. Everything else was noise. Now I focus my optimization efforts on the content that actually converts.

// Simple affiliate click tracking
router.get('/go/:affiliateId', function(req, res) {
    var affiliateId = req.params.affiliateId;
    var sourceArticle = req.query.src || 'direct';

    // Log the click asynchronously
    db.query(
        'INSERT INTO affiliate_clicks (affiliate_id, source_article, clicked_at, user_agent) VALUES ($1, $2, NOW(), $3)',
        [affiliateId, sourceArticle, req.headers['user-agent']],
        function(err) {
            if (err) console.error('Click tracking failed:', err.message);
        }
    );

    // Redirect to the affiliate URL
    lookupAffiliateUrl(affiliateId, function(err, url) {
        if (err || !url) return res.redirect('/');
        res.redirect(url);
    });
});

Mistake 5: Treating the book as a one-time project. I published my book and moved on to other things. Six months later, I realized that some of the code examples were outdated and a few APIs had changed. An outdated technical book generates refund requests and bad reviews, both of which kill sales momentum. Now I schedule a quarterly review of the book content and publish updates. It's maintenance, not glamorous, but it protects the revenue stream.

---

The Compounding Effect

Here's the thing that gets me most excited about this model: it compounds. Every article I write creates a new entry point into the funnel. Every resource page captures a new commercial search query. Every book sale creates a reader who might become a repeat customer.

At five articles per week and growing organic search traffic, my monthly page views have been increasing at about 12% month-over-month. If the monetization rate stays constant (and historically it improves as I get better at placement), the revenue curve looks like this:

Month 1:  5,000 views  → $295
Month 3:  7,000 views  → $413
Month 6:  12,000 views → $708
Month 12: 25,000 views → $1,475
Month 18: 50,000 views → $2,950
Month 24: 100,000 views → $5,900

Those projections assume consistent content production and improving SEO. They're optimistic but not unrealistic. The point isn't the specific numbers — it's the shape of the curve. Linear effort produces exponential results because content compounds.

Compare this to freelance development, where every dollar requires a corresponding hour of work. When I stop working, the freelance income stops. When I stop writing, the affiliate and book income continues. It might not grow, but it doesn't disappear. That's the difference between a job and an asset, and I spent twenty-five years building the former before I started building the latter.

---

Getting Started: The Minimum Viable Monetization

If you're a developer with a blog or side project and you want to start implementing this, here's the minimum viable version.

Week 1: Sign up for Amazon Associates and one other affiliate program relevant to your niche. Add contextual links to your three most-trafficked articles. Be genuine — only link to things you've actually used.

Week 2: Create one resource page targeting a commercial search term in your area of expertise. "Best [tools] for [your specialty] in [year]." Include five to seven recommendations with honest pros and cons.

Week 3: Start outlining a book or comprehensive guide based on your deepest area of expertise. You don't need to write it all at once — just start the outline and commit to one chapter per week.

Week 4: Set up basic tracking so you know what's working. It doesn't need to be sophisticated — even UTM parameters on your affiliate links and a spreadsheet will get you started.

The total time investment is maybe ten to fifteen hours spread over a month. The revenue won't be impressive immediately. But you're building infrastructure that pays you back for months and years, and that changes the entire economics of running a side project.

I spent thirty years trading my time for money. The tiered affiliate and book model is the first approach I've found that lets me trade my knowledge for money instead. The knowledge doesn't run out. The time always does.

Shane Larson is a software engineer, reluctant marketer, and accidental author writing from his cabin in Caswell Lakes, Alaska. He runs Grizzly Peak Software, AutoDetective.ai, and has strong opinions about affiliate disclosure that nobody asked for. Learn more at grizzlypeaksoftware.com.