I’ve been sitting on this one for ages. Every so often someone asks how a tool I once built called Social Opinion got started, or how I ended up in Twitter’s NYC office talking to their platform team about internal APIs most developers never get near.

So here’s the story.

Spoiler: I never won the #Promote developer initiative -twice, but it was still one of the best developer initiatives I took part in.  I haven’t forgot the experience or lessons learned.

I mention to people to consider what happens after cheap AI access ends. This is where some of that instinct comes from. Long before MCP or agent frameworks existed, I built something real on top of another platform’s early access, got close to the team that owned it, and watched what happened when that access disappeared.

One quick note before I get into it. This was back when it was still called Twitter, before X, before the AI stack I use today even existed. LUIS was cutting-edge. Nobody was talking about embeddings, agents, or MCP. Keep that in mind as you read, but even though the tools have completely changed, the lessons really haven’t.

~

The Origin Story

This started as a Master’s dissertation: Sentiment Analysis and Data Mining Social Networks using Bayes Theorem.  A bit of a mouthful, but the short version is: could you take raw data and tweets then work out, algorithmically, what people actually felt about something.

The dissertation software was rough. A .NET Windows app, command-line tool option, and doing just enough NLP and Bayesian classification to prove the concept.

But it worked and I decided to buy a bootstrap website and stick a web front end on it.  I called it Social Opinion. Then, in one of those moments you can’t plan for, someone on Reddit had found it and were using it to track sentiment around stock tickers.  Completely unprompted and unrelated to what I’d originally built it for.

A pleasant surprise.  That’s usually the tell that you’ve built something worth pushing a bit further.

~

Enter #Promote

In 2016, Twitter ran an Innovation Challenge, #Promote. It gave developers a chance to build something useful on top of their platform and get it in front of the people who build the platform. I decided Social Opinion was going in.

I want to be upfront about how this actually got built: evenings, weekends, and hours spent coding in airport lounges between flights visiting family in Europe. There was no team. No budget. No roadmap beyond “get this working before the deadline.”.

If you’ve ever tried to maintain momentum on a personal project around a full-time job, you already know how this goes.  Motivation isn’t the hard part, protecting your time is.

~

Overview of The Pipeline, Piece by Piece

I documented each build of the product in public as I went.  Mainly to firm up what I was doing and write notes to myself about how this was built.  Looking back, the architecture ended up more layered than I expected going in.  Some of this follows.  It’s spread into 3 main areas:

• ingestions
• real-time processing
• intent classification

Ingestion

Sentiment analysis formed part of the release for 2016.  In 2017, identifying commercial intent signals was the new feature.  I had a choice: pay a few thousand a month for GNIP’s enterprise firehose, or wire up something myself against Twitter’s Streaming API. Obviously I went with the second option.

A solo dev with zero budget doesn’t have a lot of decisions to make here. I got a filtered stream running against a single keyword (“brexit,” because in 2016 that’s what everyone was talking about).  I watched hundreds of tweets a second come through a console app. That first “it’s actually streaming” moment never gets old.

Real-time layer

SignalR sat on top of the ingestion pipe so the UI could update live rather than on a refresh cycle. Small addition, disproportionately satisfying to watch work.  These days that same “watch it happen live” feeling is just streaming tokens back from an LLM call.  In the end I didn’t include this feature in the final submission though.

Intent classification

During the 2017 submission, this is where things got interesting, and where two different pieces of NLP ended up running side by side, doing two different jobs.

The original sentiment engine, the Bayesian classifier from my Masters, was the one that had already put me through the corpus grind. Source data, cleanse it, label it, retrain when accuracy drifted. I knew how much of my life that process could eat.

So when it came to commercial intent (was this tweet an actual purchase signal?) I wasn’t doing that again. I went with Microsoft’s LUIS (image above) for exactly one reason.  I didn’t have to build and maintain a training corpus myself.

I could feed it utterances, let it handle the training internally, get a probability back. Alongside that, Stanford’s POS tagger broke each tweet down grammatically, so the intent scoring had some structure to work with rather than just raw text.

Sentiment stayed on the Bayesian classifier throughout, corpus and all. Two classifiers, two philosophies: one where someone else did the training for me, one where I was the training pipeline, and I’d earned the right to be picky about which one I signed up for twice.

If I were building this today, LUIS’s job would be a zero-shot prompt to an LLM, and the Bayesian classifier would probably be embeddings and a vector store instead of hand-coded probability scoring. Same underlying problems: “does this text express intent,” “what’s the sentiment here,” completely different toolbox.

To validate this I set up a live campaign tracking “iPhone”.

I watched the classifier assign purchase-intent probability scores to real tweets in real time, 0.70, 0.72, whatever the model landed on.

Seeing a number like that come out of a pipeline I’d built myself, against live data, from someone else’s tweet, was a genuinely different feeling than any amount of local testing.

An experimental feature was for the product to automatically DM a person that had recently expressed commercial intent.  We can see this below:

A selection of features, each adding different levels of value.  Imagine my excitement when I saw a real person replying to content that the product had auto-mentioned a sales lead directly on Twitter (image above) and they had replied.

~

What Happened With Each Submission

An overview of the timeline and each submission now follows.

2016: A Cold Email, Then a Solid Entry

I hadn’t heard back from the judges but received a direct email from  a Sr. Partner Manager on Twitter’s Ads API team.  He’s heard about the entry and emailed asking for a demo before results were even in. I spun up a test environment that same evening and walked him through it the next day.  I also had a submission deck in Twitter’s hands within 48 hours of that first email landing in my inbox.

The feedback that came back a few days later was that Social Opinion was “a solid entry.” I didn’t make the cut of the four regional finalists who’d go on to demo in front of Twitter’s executives at Demo Day. But every company that submitted a final application got one person invited to the cocktail hour and dinner in San Francisco anyway.  Unfortunately I couldn’t attend due to personal reasons.

2017: Back In, and to New York

The following spring, a catch-up email with my partner-program contact turned into news that #Promote was running again for 2017, this time with a shift toward “point solutions” rather than full campaign management.

This iteration of the product included more of the ad-tech features and commercial intent signal detection.

I RSVP’d for the NYC event that September and worked out how to route personal travel through three countries so I could make it. Once there, rather than a formal demo, my contact set up informal meetings with a couple of Twitter’s product managers, just conversation, no pitch required.  We spoke about some pain points and I came away from that with new ideas.

Second time around and I still didn’t win.  It was all still worth it though.

~

Getting Into AX

A few weeks after that trip, I followed up with some ideas from the visit and asked whether I could get a look at an internal alpha called AX. What came back wasn’t instant access, it was an introduction and a video call with the product manager running the alpha.  They walked me through a live demo. Documentation followed a couple of weeks after that, then a technical back-and-forth on how the targeting and audience-recommendation endpoints chained together, then access to a private repo for updated docs.

By mid-November I had live API access, and by December I’d wired AX into Social Opinion’s middleware, built a UI for what I called “MetaCampaigns,” and had the whole thing dynamically generating ad campaigns and tailored audiences off the combined signal.

I even got hit with a real production API version-migration deadline that December, the sort of mundane, unglamorous proof that only comes with genuine access, not a demo account.

The feature I built around all of this was Social Opinion’s Just-In-Time (JiT) Audience File, which is also where the “Just-in-Time Audiences” name in my second #Promote entry came from.  Not a new pitch invented for the competition, but the real thing I was already building with the help of Twitter’s team. That December, one of Twitter’s own engineers asked me directly for feedback on a parameter they’d de-scoped from the beta, so they could “make a case to our product teams.”.

That’s the moment that still sticks with me more than any invite or badge: an outside indie developer being asked to help shape what a platform team builds next.

By January 2018 I’d pushed further still, extending the integration into a demographics layer.

~

What AX Became

About six months after that first AX introduction, the capability shipped publicly as Audience Intelligence.

This was one of the details that stuck in my mind.  The intro to AX wasn’t a courtesy tour. It was real engagement with a product team with an indie developer.

~

The Relationship Outlasted the Program

The relationship kept paying out long after #Promote itself was over. A few years later, Twitter created the Developer Insider program. This was created to recognise developers who’d stayed engaged and given back to the platform and I was named one of the Insiders. That came with its own second-order effect: an ongoing channel with Twitter’s developer advocates and marketing team, the kind of access that doesn’t show up in any single blog post but compounds quietly in the background.

~

What I’d Tell Past Me

Winning was never really the point, even though it felt like it at the time. The actual return on this project wasn’t a trophy. It was two separate invitations to Twitter HQ, a direct line to their platform team, early access to unreleased APIs, and eventually a Microsoft MVP nod that traces its roots straight back to this body of work.

If I’d measured success purely by “did I win the challenge,” I’d have called all of this a failure. I didn’t win but gained so much from the experience.  Some thoughts on this:

• Not every problem needs the same solution. I could have tried to force one classifier to handle both intent and sentiment. Instead I let LUIS take the job I didn’t want to own the training data for, and kept my own Bayesian classifier for the job where hand-tuning the training set actually mattered.
• Match the tool to the job. Not the job to your favourite tool.  Outsource the parts where someone else’s training beats yours, keep the parts where precision is worth the grind. That calculation hasn’t changed, only the tools have. It’s the same question today when you’re choosing between an off-the-shelf LLM call and fine-tuning your own model.
• Show up more than once. One entry to #Promote made me a name Twitter’s team recognised for a season. A second entry, a year later, is what turned that into an actual relationship.  The kind that gets you nudged when a program’s about to open, not just remembered as someone who tried once. A single hackathon entry is a data point. Two years running is a pattern a DevRel team actually notices.
• Report bugs like an engineer, not a user. Years after #Promote, when a Twitter API v2 migration broke my OAuth callback, I didn’t just tell DevRel “it’s broken.” I isolated exactly which callback URLs failed and which didn’t, tested the pattern systematically, and handed them a specific, reproducible cause instead of a vague symptom. They had it fixed within 24 hours. That’s not access or luck. It’s the difference between a report anyone can shelve and one a platform team can act on immediately, and it works whether or not you’ve got a relationship with the people reading it.
• Document as you build, not after. The fact I’ve got a genuine, dated, technical paper trail of this whole thing, not a tidied-up retrospective written from memory, is why I can still point back to it years later and have it hold up. Future you will thank present you for writing it down while it’s still messy and real.
• Organic adoption is the loudest signal you’ll get. Nobody told me to build stock-sentiment tracking into Social Opinion, Reddit users just started using it that way.

Years later, someone reached out, unprompted, wanting functionality to mine Twitter for financial insights, and by early 2018 I was onboarding test users for financial and cryptocurrency use cases nobody had asked me to build.

Three separate unprompted signals, years apart but the same pattern. That’s worth paying attention to every single time it happens.

~

Why I’m Telling You This Now, in 2026

Here’s the thing that made me finally write this up properly, years later.  The pattern hasn’t gone anywhere.

I wrote about this same instinct more directly a little while back in “I’ve Seen This Pattern Before: Are You Building for What Comes After Cheap AI Access?“.

Getting hands-on with Twitter’s internal “AX” API before it became Audience Intelligence wasn’t really about Twitter. It was about what happens when you get close enough to a platform’s own team that you start seeing the roadmap before the rest of the market does.  A bit of an advantage, especially when your resources are tight.

That dynamic is exactly what’s playing out right now with AI platforms.

The developers building early on MCP, the ones in close contact with a platform’s DevRel teams, the ones showing up to feedback sessions with something real already built, they’re the developers who’ll look back in five years and point to early access they didn’t fully appreciate at the time.

The tools are unrecognisable. LUIS is gone. Nobody’s hand-rolling Bayesian classifiers in C# anymore when a prompt will do the job in a few seconds.

But the mechanisms that matter are still there.  Building something real, putting it in front of the people who own the platform, and letting relationships do more work than the code ever can, that part is identical.

If anything, it’s more true now, because the barrier to building “something real” has dropped so far that the differentiator isn’t the build anymore. It’s whether you show up and execute.  Tools like Claude Code make shipping rapid.

If any of this sounds familiar, a few questions worth actually sitting with rather than skimming past:

• What’s your fallback if this API or model access disappeared tomorrow? Do you have one, or would you be starting from zero?
• Are you the platform’s customer, or are you the thing it’s optimising around? Free and cheap access usually means the latter, right up until it doesn’t.
• Could you migrate off this dependency in 30 days if you had to? If the honest answer is no, that’s the gap worth closing now, while you still have the luxury of time to close it.
• Are you actually showing up to the relationship (feedback, bug reports, community programs) or just consuming the API and hoping nobody changes the terms?

 

I didn’t ask myself any of these in 2017. It mostly just worked out that way.  This was more luck than judgement. You don’t need to rely on luck if you ask yourself these questions now.

If you’re deep in an agent framework right now, or building on top of MCP, or just quietly shipping something nobody asked for -pay attention to who notices. That might be the direction you end up moving towards and where your story ends up.

~

Where This Leaves Things

Social Opinion never became the big commercial thing and I’m fine with that. I made a little money but nothing major.  I ended up shutting it down entirely a few years back, no dramatic ending.  What I can say is that I’m glad I documented what I was doing in real-time.  The lessons learned and relationships that developed were more valuable than the tool in the end.

What it did become, before all that, was the foundation for almost everything that followed. The MVP award, the courses, the ongoing pull toward AI/ML work that’s now basically the entire second half of my career.

Sometimes the side project that “doesn’t win,” and eventually doesn’t even survive, is still the one that changes your trajectory.

If you’re sitting on something half-built right now, built out of hours you probably shouldn’t have spared: finish it anyway. You don’t need to win the thing you built it for. You just need it to be good enough that someone with the keys to something bigger decides you’re worth a conversation.

If you want the blow-by-blow technical build log rather than the retrospective, the original #Promote series is still up on the blog: firehose ingestion, SignalR experiments, LUIS, POS tagging etc.

There’s no #Promote-equivalent to chase anymore, that said, there are dozens of MCP and agent hackathons running right now instead of one flagship event.

Google Cloud’s Rapid Agent Hackathon, the various MCP-focused challenges on Devpost and HackerEarth, NVIDIA’s Agent Toolkit hackathon, the open-source cloud-native MCP hackathon built around tools like agentgateway and kagent: pick one, or don’t wait for one at all and just ship the thing you’re already building.

None of them owe you an invite to Meta, Anthropic, X, etc, and chasing the prize is exactly the wrong lesson to take from this post. But showing up, building something real, and letting the right person notice, all of that is still on the table, and it’s more accessible now than it’s ever been.

~

~