Over the last several years at Zango, one of the constant questions I'm faced with is when to build a particular technology ourselves, when to rent it, and when to buy it. Like many tech guys, my instinct is that we should build it ourselves. The problem isn't that this instinct is wrong: it's that it's right just often enough that it can make it hard to see when it's misplaced.
Here's a great example of how it gets complicated. When we first founded Zango, back in 1999, we were so busy trying to establish a technology baseline that we outsourced everything that we possibly could, including our ad serving. Over the first two years, we went through three or four different ad serving companies, trying to find one that would meet our needs, and swapping them out on a regular basis. Finally – I remember the day – Keith dropped into my office and said, "We need our own ad server. None of these others can handle the kind of keyword targeting we need. I need you to drop everything and build it."
So I did. It was horribly simplistic, badly designed, constructed with virtually no input from our advertisers, and built – of all things – in classic ASP, with MS Access as the administration tool. (Hey, when the only tool you've got is a hammer...) But it worked. Our sales people and account managers loved it, because it let them do keyword targeting of their ads in a fraction of the time that it had previously required. The keyword targeting was at least an order of magnitude better than anything we'd been able to get with our other ad servers: not because I was a better programmer or because we had better algorithms, but because it was designed around our specific needs.
Now, five or six years later, that same ad delivery system is showing its age. It's worked very well for us so far, we've added a ton of features, migrated it to C# and ASP.NET, made it more scalable by an order of magnitude – but it's still fundamentally the same system I designed in a couple of days, back when Zango consisted of only five people. We now have more than two hundred employees, thousands of advertisers, and more to the point, competitors that haven't stood still either. Self-serve, keyword-based targeting was a reasonably snazzy idea seven years ago: but these days, we need a system that can optimize itself, without user intervention; and which can optimize based on dozens or even hundreds of different variables. (Don't get me wrong, by the way: we still deliver a better ROI for our advertisers than Google does. But we want to deliver a much better ROI.)
Which is where it gets complicated. Should we build this system ourselves? Should we try to buy a company that already has one? Or should we try to munge our system into working with any of the dozens of public ad serving systems already out there? This is an idea we've been hashing over for a while, and we've gone different directions.
While I'm open to ideas – anyone out there have any suggestions? – our current approach is that we're going to try to build it ourselves. We've got several reasons:
- Strategically, we think the company will be worth more long-term if we own this IP rather than just rent it from someone else.
- Tactically, it's a huge risk if our ad serving company turns us off (as, say, SDC did just a few months ago to all its customers, after its acquisition by Fox Interactive).
- Technically, it's been my experience that plugging in somebody else's technology, when it's as central and critical as this is, is almost as huge a pain as building it ourselves.
The next hard part is getting the algorithms right. That's not an area where I have any expertise, and I'm going to have to depend a lot on other folks. And that's nearly as much a pain as outsourcing.