Cross-Pollinating Audiences: How a Job Board Feeds a Diagnostics Tool (and Vice Versa)

Most developers build one product at a time and market it in isolation. I know because I did this for years and it's an incredibly inefficient way to operate.

You build a thing. You market the thing. You build another thing. You market that other thing. The audiences never overlap. The marketing effort for product B doesn't help product A. Every launch starts from zero. It's exhausting and it doesn't scale.

About six months ago I accidentally stumbled into something better. I was running two products — a job board aggregating remote software engineering positions and AutoDetective.ai, a vehicle diagnostics tool — and I noticed something strange in my analytics. Users were crossing over between them. People who found Grizzly Peak Software through job listings were clicking through to the diagnostics tool. People who came in through automotive diagnostics searches were browsing job postings.

At first I thought this was noise. Then I realized it was a strategy I hadn't been smart enough to implement intentionally.

---

The Accidental Discovery

Let me set the stage. Grizzly Peak Software runs a job board that aggregates remote tech positions. It pulls from multiple APIs, classifies jobs into career categories using Claude Haiku, and presents them in a clean, searchable interface. It's one piece of a larger content ecosystem that includes technical articles, a library of resources, and promotional content for my book about training LLMs.

Separately, I run AutoDetective.ai — a vehicle diagnostics tool that helps people understand what's going on with their cars. Different product, different audience, different value proposition entirely.

Or so I thought.

Here's what the data showed me: the audiences weren't as different as I assumed. Software engineers who browse remote job listings also own cars. Car owners who are technically inclined enough to use an AI diagnostics tool are often in tech-adjacent careers. The Venn diagram had more overlap than I expected.

The first signal was referral traffic. I noticed sessions where users would land on a job listing, spend time browsing positions, then navigate to the main Grizzly Peak Software site, read an article, and click through to AutoDetective.ai. The journey was organic and unforced. Nobody was pushing them through a funnel. They were exploring because the ecosystem gave them reasons to explore.

---

Why Cross-Pollination Works for Independent Developers

Big companies have known about this forever. Amazon sells you a Kindle so you'll buy ebooks. Apple sells you an iPhone so you'll subscribe to iCloud. Google gives you Gmail so you'll use Google Drive. Each product feeds the others.

Independent developers rarely think this way. We're too focused on the individual product to see the ecosystem potential. But the mechanics are the same at any scale.

Here's the framework I've landed on after watching this play out:

Shared infrastructure reduces costs. My job board and my content site run on the same Express.js application, the same PostgreSQL database, the same DigitalOcean droplet. The marginal cost of adding the job board to my existing infrastructure was close to zero. If I'd built it as a standalone product, I'd be paying for separate hosting, a separate domain, separate SSL certificates.

// Same Express app serves multiple product verticals
var express = require('express');
var app = express();

// Content routes
app.use('/articles', require('./routes/articles'));
app.use('/library', require('./routes/library'));

// Job board routes
app.use('/jobs', require('./routes/jobs'));

// Ad system that cross-promotes across all verticals
app.use('/ads', require('./routes/ads'));

// One server, one deployment, one monitoring stack
app.listen(process.env.PORT || 8080);

Shared audience compounds reach. Every person who visits the job board is a potential reader of my articles. Every article reader is a potential job board user. Every person in either audience might need vehicle diagnostics. The traffic from one product lifts all the others.

Trust transfers between products. This is the subtle one. When someone reads three or four of my technical articles and finds them useful, they're more likely to trust my job board. When someone uses the job board and has a good experience, they're more likely to try AutoDetective.ai. Trust built in one context carries over to others because everything is under the same brand umbrella.

---

The Mechanics of Cross-Pollination

Let me get specific about how I actually implemented this, because "cross-pollinate your audiences" is the kind of advice that sounds great in a business book but means nothing without execution details.

Strategic placement of cross-links. On every job detail page, there's a sidebar. That sidebar shows related articles and a subtle mention of AutoDetective.ai. It's not aggressive. It's not a popup or an interstitial. It's a natural part of the page layout.

On article pages, the same sidebar shows relevant job listings. If someone's reading an article about Node.js API development, the sidebar shows Node.js job postings. The relevance makes it useful rather than spammy.

// Simplified version of cross-promotion logic
function getRelatedContent(currentPage, category) {
    var related = {
        articles: [],
        jobs: [],
        tools: []
    };

    if (currentPage.type === 'job') {
        // Show articles related to the job's tech stack
        related.articles = fetchArticlesByCategory(category);
        related.tools = [{ name: 'AutoDetective.ai', context: 'sidebar' }];
    }

    if (currentPage.type === 'article') {
        // Show jobs related to the article's topic
        related.jobs = fetchJobsByCategory(category);
        related.tools = [{ name: 'AutoDetective.ai', context: 'sidebar' }];
    }

    return related;
}

The ad system as connective tissue. I built a lightweight ad system that serves promotional content across all parts of the site. This isn't third-party advertising — it's my own ad units promoting my own products. The ad system tracks impressions and clicks, which gives me data on which cross-promotions actually work.

An inline ad in a job listing might promote my book. A sidebar ad on an article page might highlight AutoDetective.ai. A feed ad in the job search results might link to a relevant tutorial. The ad system is the mechanism that ties the ecosystem together.

Email as the unifying channel. Newsletter subscribers get content that spans the entire ecosystem. A weekly email might include a new article, three interesting job postings, and a tip about using AutoDetective.ai. The subscriber doesn't think of these as separate products — they think of it as "that useful newsletter from the guy in Alaska."

---

What the Numbers Actually Look Like

I'm not going to pretend the numbers are enormous. I run this from a cabin in Caswell Lakes, Alaska, not from a venture-funded startup in San Francisco. But the ratios are interesting.

Before I started intentionally cross-pollinating, each product existed in its own silo. The job board got traffic from Google searches for remote tech jobs. AutoDetective.ai got traffic from automotive diagnostic searches. The articles got traffic from programming tutorial searches. Almost zero cross-traffic between them.

After six months of intentional cross-pollination, roughly 15% of job board visitors also read at least one article. About 8% of article readers browse job listings. And about 3% of the combined audience clicks through to AutoDetective.ai at least once.

Those percentages sound small. But here's why they matter: that cross-traffic is free. I'm not paying for it. I'm not running ads on Google or Facebook to drive it. It happens because the products exist in the same ecosystem and the cross-links are there.

The compounding effect is what makes this powerful. A user who came for a job listing, read an article, and bookmarked AutoDetective.ai might come back three months later when their check engine light comes on. That's a conversion I never would have gotten if the products were isolated.

---

The Diagnostics Tool Benefits Most

Here's something I didn't predict: the product that benefits most from cross-pollination is AutoDetective.ai, which is the most different from the core content.

The reason is trust asymmetry. When someone discovers AutoDetective.ai through a Google search, they have zero context about who built it. It's just another tool on the internet. They might try it, or they might bounce.

But when someone discovers AutoDetective.ai through Grizzly Peak Software — after reading a few articles, maybe browsing some job listings — they already have a relationship with the brand. They know there's a real person behind it. They've seen quality content. They've built trust incrementally.

The conversion rate for AutoDetective.ai visitors who came through the content ecosystem is roughly triple the conversion rate for cold search traffic. Triple. Same product, same landing page, same value proposition. The only difference is the trust that preceded the visit.

This is why I now think about every new product in terms of how it connects to the ecosystem, not just how it stands alone.

---

Lessons for Solo Developers Building Multiple Products

If you're a solo developer or a small team running multiple projects, here's what I've learned about making cross-pollination work:

Build on shared infrastructure. Every product you build should share as much infrastructure as possible with your existing products. Same hosting, same database technology, same deployment pipeline. This isn't just about cost — it's about cognitive overhead. The less context-switching you do between products, the more time you spend actually building.

Make the connections useful, not forced. Cross-promotion only works when it's relevant. Showing job listings to someone reading an API tutorial makes sense. Showing job listings to someone debugging their car's transmission does not. Relevance is what separates cross-pollination from spam.

Track the cross-traffic. You can't optimize what you can't measure. I track which cross-links get clicked, which products users visit in a single session, and which cross-promotions lead to conversions. Without this data, you're guessing.

// Simple cross-traffic tracking
function trackCrossVisit(req, res, next) {
    var sessionProducts = req.session.productsVisited || [];
    var currentProduct = identifyProduct(req.path);

    if (sessionProducts.indexOf(currentProduct) === -1) {
        sessionProducts.push(currentProduct);
        req.session.productsVisited = sessionProducts;
    }

    // Log cross-visit when user has seen 2+ products
    if (sessionProducts.length >= 2) {
        logCrossVisit({
            products: sessionProducts,
            entryPoint: req.session.entryProduct,
            timestamp: new Date()
        });
    }

    next();
}

The ecosystem is the moat. Any individual product I build can be replicated by someone with more resources. A better job board exists. Better diagnostics tools exist. Better technical content exists. But the combination — the ecosystem where each piece reinforces the others — is much harder to replicate. The whole is genuinely more valuable than the sum of its parts.

---

What I'd Do Differently

If I were starting from scratch, I'd be intentional about cross-pollination from day one instead of stumbling into it accidentally. Here's my revised playbook:

Start with content. Articles, tutorials, guides. This is your trust-building layer. It's the foundation everything else sits on.

Add a community-adjacent feature. For me, that's the job board. It brings people back regularly and creates habitual traffic. A job board, a forum, a tool directory — anything that gives people a reason to return.

Layer in a commercial product. This is AutoDetective.ai in my case. Something that generates revenue and benefits from the trust you've already built.

Connect everything through shared navigation, cross-links, an ad system, and email. Make it feel like one ecosystem, not three separate websites that happen to share a domain.

The mistake I made was building each piece independently and only connecting them after the fact. The connections should be designed in from the beginning.

---

The Bigger Picture

There's a reason this matters beyond just driving traffic numbers. When you cross-pollinate audiences, you're building something that's genuinely resilient.

If Google decides to tank my article rankings tomorrow, the job board still brings people in. If the job market cools down and job board traffic drops, the articles still generate organic search traffic. If a competitor launches a better diagnostics tool, the ecosystem keeps AutoDetective.ai visible through channels the competitor doesn't have.

Diversification isn't just a financial strategy. It's a traffic strategy, a trust strategy, and a survival strategy.

I'm typing this at my desk watching snow pile up on the spruce trees outside my window. The server is humming along on DigitalOcean, serving job listings to someone in Austin, articles to someone in Berlin, and diagnostics to someone in Sydney. Three products, one ecosystem, all feeding each other.

That's the game. Not building the best individual product. Building the best connected collection of products that make each other stronger.

Shane Larson is a software engineer and technical author based in Caswell Lakes, Alaska. He runs Grizzly Peak Software and AutoDetective.ai, and has published a book on training LLMs with Python and PyTorch. When he's not writing code or articles, he's probably clearing snow off something.