Case study — capstone project, Product Management, IIT Roorkee

I turned a $50 affiliate link into an automated revenue loop.

Developer-tool companies pay real money — a flat fee or a share of lifetime revenue — for every developer they acquire. I built a fully automated system that finds the right developer, at the right moment, and puts the right offer in front of them. No manual posting. No chasing clients.

See how the loop works View the actual workflow

$50–$100 per signup · fully automated via n8n · Business Ops → AI Automation

The problem

Affiliate programs are lucrative. Distribution is still manual.

Platforms like Supabase, DigitalOcean, WP Engine, Kinsta, and Cloudways — developer tools and premium cloud infrastructure alike — compete for the same scarce resource: builders who'll actually deploy on them. Paid ads are expensive and easy to ignore. So these companies run affiliate and referral programs instead — paying out real money, sometimes a flat bounty, sometimes a percentage of a customer's spend for as long as they stay.

The economics are generous. The execution usually isn't. Most affiliate activity is one person, writing one post, hoping it lands in front of the right developer at the right time. It doesn't scale, and it isn't targeted — which means most of that budget goes unclaimed.

That gap — real incentive, weak distribution — is the business problem this project exists to close.

The programs already pay for the outcome. What's missing isn't more content — it's a system that shows up consistently, in the right niche, without a person behind every post.

— the thesis behind The Loop

Why it's worth building

The math behind the loop.

Four numbers that make automation worth more than manual outreach here.

$50–100 Flat payout per developer signup on most dev-tool affiliate programs

LTV % Some programs pay an ongoing share of what that developer spends, for as long as they're a customer

$0 Ad spend required — distribution runs through organic, targeted content instead

24/7 The workflow runs on a schedule — it doesn't wait on me to remember to post

The system

Five stages. One closed loop.

Every cycle feeds the next. The workflow doesn't just publish content — it learns which niches and formats actually convert, then narrows in on them.

Signal

The workflow scans a defined technical niche — a category like database migrations or serverless deploys — for developer conversations and keyword patterns that suggest active interest.

Filter

Keywords are narrowed against a target list of live affiliate programs, so the workflow only acts on genuine overlap between what developers are discussing and what actually pays out.

Generate

An LLM drafts a LinkedIn post grounded in that specific niche — a real explanation or comparison, not a pitch — with the tracking link placed where it's actually useful to the reader.

Publish

n8n posts on a fixed cadence. Distribution no longer depends on whether I remembered to sit down and write something that day.

Convert & reinvest

Clicks and signups are tracked back to the originating post, so I can see which niches and formats actually pay — and feed that back into stage one for the next cycle.

Under the hood

What's actually running this.

No dashboard theatre — this is the real workflow, built and orchestrated in n8n.

Orchestration

n8n

The backbone of the system, self-hosted rather than paid for. Every stage — scanning, filtering, generation, publishing — runs as a connected, schedulable workflow.

Infrastructure

Docker

n8n runs inside a self-hosted Docker container, so the workflow has a stable, free home instead of a metered cloud plan.

Content

Ollama (local LLM)

Runs the model locally rather than through a paid API, drafting each post grounded in the niche signal it's given.

Data & looping

Airtable

Stores the source records and niche data the workflow loops over — the connective layer between signal and generation.

Distribution

The current channel of choice — a professional audience of exactly the developers these affiliate programs want.

Attribution

Tracking layer

Unique links per post close the loop, connecting a specific piece of content back to a specific signup.

Screenshot of the actual n8n automation workflow powering The Loop, showing connected nodes for signal detection, content generation, and publishing.

The live workflow — not a mockup.

What was hard

The parts that don't show up in a demo.

Challenge 01

Running the LLM without paying per call

I didn't want every generation step depending on a metered API, so I installed Ollama to run the model locally. Getting it installed and talking to n8n reliably wasn't a checkbox — it was real configuration work, node by node.

→ Got Ollama installed, connected, and holding a stable connection inside the workflow.

Challenge 02

Self-hosting n8n in Docker

Running n8n for free meant self-hosting it, which meant learning Docker first. That setup alone took a while to get right — before I'd even built a single node of the actual loop.

→ Learned Docker from scratch just to give the workflow a stable, free home to run on.

Challenge 03

Wiring Airtable into the loop

Airtable is where the workflow stores and loops over its records, but getting it to pass clean data into the LLM step — and loop over it correctly — took the longest to settle. Small mismatches broke the whole cycle.

→ Rebuilt the Airtable → LLM → Loop connection until it ran end to end without breaking mid-cycle.

Why I'm building this

From running operations to building the system itself.

I've spent my career in business operations — solving problems by tightening process, aligning teams, and making sure the right thing happened at the right time. Moving into AI automation, I didn't want to prove I could prompt a chatbot. I wanted to prove I could design an actual system: an incentive structure, a distribution engine, and a feedback loop that improves itself.

This project is also my capstone for the Product Management program at IIT Roorkee — not because it was assigned, but because it's the clearest way I know to show how I think about a problem end to end: the business case, the mechanism, the trade-offs, and the plan for what's next.

Foundation

Business Operations

Years spent inside real processes — where inefficiency actually costs money, and where the fix has to work, not just sound good.

In progress

Product Management, IIT Roorkee

Formalizing how to frame a problem, size an opportunity, and design a solution before writing a single line of automation.

Current

AI Automation, applied

The Loop is where that thinking becomes something real: shipped, running, and generating an outcome I can measure.

What's next

Where the loop goes from here.

Next up

Expand beyond dev tools

Apply the same signal → filter → publish mechanism to affiliate programs outside the developer-tool category.

Next up

A real performance dashboard

Replace scattered logs with a single view of which niches, formats, and programs are actually converting.

Exploring

New distribution channels

Test whether the same loop holds up on channels beyond LinkedIn, without losing the "genuinely useful" bar.

Shubham Kilaji · Founder, The Loop

Building something that actually earns its keep.

Open to conversations about AI automation, product roles, or the affiliate programs this loop is built to serve.

Email me Connect on LinkedIn