To my friends who died ten years ago, I hope you had a fortunate rebirth.
To my friends who had family members die, may your loved ones find happiness.
To my son, born 42 weeks and one day later: there is only loss if there is love, the way forward is always through love.
Sunday, September 11, 2011
Thursday, August 4, 2011
How I Wrote VCBar
All the people ask meMy friend Chris Wiggins asked me to post the code for the VC bar chart generator I blogged earlier this week. It's here.
How I wrote elastic man.
- The Fall
It's an interesting project if only because it's run entirely on the client-side. There's no server side (except, of course, for delivering the files to you.) This is possible because the Crunchbase API supports JSON callbacks. Every bit of code in the git repo is as you see it on http://neuvc.com/labs/vcbar.
But in the spirit of making the source code available, I'm going to go one better and show you how to write your own visualization of Crunchbase data. Because there's no server-side, you can play with this code on your computer with nothing more than a text editor and a web browser.
Adapt this code to visualize other data sets: people respond to visualizations and, as this shows, it's not very hard to make them.
This code is going to be as bare as possible, no bells and whistles. I hope to illustrate just the bones of it. You can add bells and whistles and DTD declarations to your hearts' delight, but this works too.
*****
The program will be broken into three parts: the HTML, the CSS and the Javascript.
The HTML
Create a directory on your computer, download d3.js from https://github.com/mbostock/d3/archives/master, unzip the archive and move the file d3.js into your new directory. Then create a file named index.html in the directory. Put this in it:
<html>
<head>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.5.2/jquery.min.js"></script>
<script src="d3.js"></script>
<script src="vcbar.js"></script>
<link rel="stylesheet" type="text/css" href="vcbar.css" />
</head>
<body>
<div id="barchart">
</div>
<div id="controls">
<a href="#" id="union-square-ventures">Union Square Ventures</a>
<a href="#" id="true-ventures">True Ventures</a>
</div>
</body>
</html>
Pretty simple. The
head loads the javascript (including jQuery from Google's CDN) and the CSS. The body has two divs, one named "barchart"--this is where the javascript will put the chart object itself--and one named "controls", where links for the two VC firms this example will link to will live. Note that the links do not link anywhere. We will use the javascript to execute an action when a link is clicked.The Javascript, part 1: Getting and Parsing the data
Put all the javascript into a file called vcbar.js in the same directory as index.html.
There are three things we want to do in the program:
1. Detect when one of the links is clicked;
2. Get and parse the data;
3. Display the bar chart.
The first is easy, especially using jQuery:
$(document).ready(function () {
$("a").click(function () {
var vc = $(this).attr("id");
$.getJSON("http://api.crunchbase.com/v/1/financial-organization/" +
vc + ".js?callback=?",parseCB);
return;
});
});
This code uses jQuery (the '$') to run an anonymous function every time an
<a> tag is clicked. The function first gets the id attribute of the clicked tag (which we set to Crunchbase's unique identifier, their 'permalink') and then uses jQuery to execute an Ajax call for JSON, with a callback. The empty return does nothing except prevent the default click action. The enclosing document.ready method makes sure the script won't try to attach the code until after the HTML is loaded.Part of the reason this site can do everything it does on the client-side is because Crunchbase's API supports JSON callbacks. In general, client-side Javascript can't go willy-nilly fetching things from other sites because of the same origin policy enforced by browsers for security purposes. But if you're trying to pull the data from a site that supports JSON with callbacks, you can easily get data from it.
The getJSON function sends a request to Crunchbase for the VC's data. You can see an example of the raw JSON here. When the data returns it calls the callback function--parseCB--with the JSON as the argument. Note that this happens asynchronously, so if you send multiple calls (as with the vcbar site, when you click one of the subset buttons) the data does not necessarily come back in the order you asked for it. Or, maybe, at all. The callback function gets called once for each set of JSON. You need to think through the implications, in some cases.
Here we're asking for one set of data, so it's easy. Here's
parseCB:var parseCB = function(jsn) {
var idx, yr, mo,
byear=2005, eyear=2011,
months=(eyear-byear+1) * 12,
data=[];
for (var i=0; i < months; i+=1) { data[i] = 0; };
if ("investments" in jsn) {
for (var i in jsn["investments"]) {
var j = jsn["investments"][i];
if ("funding_round" in j) {
yr = j["funding_round"]["funded_year"];
mo = j["funding_round"]["funded_month"];
if (!yr || !mo || (mo == "None")) { continue };
idx = (parseInt(yr)-byear) * 12 + parseInt(mo) - 1;
if (idx < 0) { continue };
data[idx] +=1;
};
};
};
return bchart(data,byear);
};
The first few lines declare the function's variables. They set the beginning year to 2005, the end year to 2011 and then calculate the number of months in that span. Then it creates an array with a zero value for each month.
The function then parses the JSON. Go look at the raw JSON at the link above again, if you want to see what's going on here. First it tests to see if there is an "investments" key in the JSON. If there is an investments key, the corresponding value will be an array with an entry for each investment. Each entry in this array will be a dictionary with keys for "funded_year" and "funded_month".
parseCB first tests to make sure that neither the year nor the month is empty and that the month is not "None", then computes how many months from beginning of 2005 (byear) until the investment was made. It then increments the array element representing that month.When it is finished slotting each investment into a month, it calls
bchart, the charting function.The Javascript, part 2: Charting
The bar chart function is essentially cribbed from Mike Bostock's bar chart tutorial. It uses the d3.js data manipulation library to create a SVG element in the HTML.
Here's the code, broken into chunks so I can explain it. It's all inside a
var bchart = function (data, byear) {
...
};
First, let's set up some variables.
h is the height, totw is the total width, w is the width of each bar, lgst is the largest value in the data to be charted, tks is the number of horizontal ticks we want, years is an array of years from the beginning year (byear) to the end year (this is used to label the x-axis.)y is a special d3 function that maps the 'domain' to the 'range'. In this case, it maps a value from 0 to lgst to the range 0 to h. That is, y(x) = x * h / lgst. This scales the bars so the largest value in the data is the height of the chart.var h = 300, totw = 800, w = totw / data.length, lgst = d3.max(data), tks = Math.min(lgst,5), years = d3.range(byear,byear+data.length/12+1), y = d3.scale.linear() .domain([0,lgst]) .range([0,h]);
Then, let's get rid of any chart that happens to already be there, so we don't keep adding new charts one after the other.
$(".chart").remove();
Now we add a SVG element to the
div with id="barchart". We will make it wider than totw and higher than h so we have room to add the axes and their labels.// insert SVG element
var chart = d3.select("#barchart")
.append("svg:svg")
.attr("class","chart")
.attr("width", totw+40)
.attr("height", h+40);
Then we'll add the x and y-axis ticks, the light gray lines that help us see what the values are. We use a built-in d3 function called
ticks, which chooses sensible values for the ticks based on tks, the number of ticks we want. The way d3 works (and I'm not going to explain this in too much depth, you can go to the d3 site for much better explantions) is that it takes an array of data (the data method below the select ), iterates through each item and uses the enter method to put that data into existing svg elements that match the select. If there are not enough existing elements, it appends them, as here.The below code iterates through each of the ticks generated by
ticks and appends a new svg:line with attributes (x1, y1) and (x2, y2). The methods chained after data can have anonymous functions that have access to the data in the array (d) and the index of the data (i). For instance, the y-axis ticks have an x1 of 20 (I've added an offset of 20 to all the x values to accomodate the y-axis labels) and an x2 of totw+20. The y1 and y2 value are trickier. They are both the same (it's a horizontal line) and they both take the d value (where the tick is), scale it using the y function and then subtract that value from h, because the origin of the svg plotting area, the (0,0) point, is in the top left whereas our chart's (0,0) point is in the bottom left.The text labels do something similar. The y-axis uses the tick value as a string for the text and the
dx attribute to move the label slightly before the axis itself. The x-axis uses the array of years we created earlier as labels, and centers them between ticks. // create y-axis ticks
chart.selectAll("line.hrule")
.data(y.ticks(tks))
.enter().append("svg:line")
.attr("class","hrule")
.attr("x1",20)
.attr("x2",totw+20)
.attr("y1",function(d) { return h-y(d); })
.attr("y2",function(d) { return h-y(d); })
.attr("stroke","#ccc");
// label y-axis ticks
chart.selectAll("text.hrule")
.data(y.ticks(tks))
.enter().append("svg:text")
.attr("class","hrule")
.attr("x",20)
.attr("y",function(d) { return h-y(d); })
.attr("dx",-1)
.attr("text-anchor","end")
.text(String);
// create x-axis ticks
chart.selectAll("line.vrule")
.data(years)
.enter().append("svg:line")
.attr("class","vrule")
.attr("y1",h+10)
.attr("y2",0)
.attr("x1",function(d) { return (d-byear)*w*12 + 20; })
.attr("x2",function(d) { return (d-byear)*w*12 + 20; })
.attr("stroke","#ccc");
// label x-axis ticks
chart.selectAll("text.vrule")
.data(years)
.enter().append("svg:text")
.attr("class","vrule")
.attr("y",h)
.attr("x",function(d) { return (d-byear) * w * 12 + w * 6 + 20; })
.attr("dy",10)
.attr("text-anchor","middle")
.text(String);
Now we create the data bars. Here we feed the d3 the array of data. For each of the data elements it creates (using
enter) a new svg:rect, a rectangle. Each rectangle has x and y as its top left point and a width and height. The rectangles will also be styled by the CSS, which we'll talk about later on. // create bars
var bars = chart.selectAll("rect")
.data(data)
.enter().append("svg:rect")
.attr("x", function(d, i) { return i * w + 20; })
.attr("y", function(d) { return h - y(d); })
.attr("width",w)
.attr("height", function(d) { return y(d); });
And, finally, the x and y axes. The reason we create the ticks first, then the bars and then the x and y-axis is that this is the order of layering we want, ticks at the bottom, bars on top of them, then the axes.
// create x-axis
chart.append("svg:line")
.attr("x1",20)
.attr("y1",h)
.attr("x2",totw + 20)
.attr("y2",h)
.attr("stroke","#000");
// create y-axis
chart.append("svg:line")
.attr("x1",20)
.attr("y1",h)
.attr("x2",20)
.attr("y2",0)
.attr("stroke","#000");
Don't forget to include the function declaration before all the chart code and the '};' after it all. Just saying. Also, the javascript should have the functions first, so essentially in the opposite order presented here. I've put all the javascript in one contiguous piece at the bottom*.
That's the chart. After that, the CSS is a piece of cake.
CSS
Nothing fancy here. Put it in a file called vcbar.css in the same directory as index.html.
.chart {
margin-left: 40px;
font: 10px sans-serif;
shape-rendering: crispEdges;
}
.chart rect {
stroke: white;
fill: steelblue;
}
And that's it. If you put this code into files on your computer and open index.html from your web browser, you should get a chart. Then go and change the code and see what happens, or add lots more code and do something really, really cool. When you do, tweet me, I want to see it.
-----
* vcbar.js, in total:
var bchart = function (data, byear) {
var h = 300,
totw = 800,
w = totw / data.length,
lgst = d3.max(data),
tks = Math.min(lgst,5),
years = d3.range(byear,byear+data.length/12+1);
$(".chart").remove();
var y = d3.scale.linear()
.domain([0,lgst])
.range([0,h]);
// insert SVG element
var chart = d3.select("#barchart")
.append("svg:svg")
.attr("class","chart")
.attr("width", totw+40)
.attr("height", h+40);
// create y-axis ticks
chart.selectAll("line.hrule")
.data(y.ticks(tks))
.enter().append("svg:line")
.attr("class","hrule")
.attr("x1",20)
.attr("x2",totw+20)
.attr("y1",function(d) { return h-y(d); })
.attr("y2",function(d) { return h-y(d); })
.attr("stroke","#ccc");
// label y-axis ticks
chart.selectAll("text.hrule")
.data(y.ticks(tks))
.enter().append("svg:text")
.attr("class","hrule")
.attr("x",20)
.attr("y",function(d) { return h-y(d); })
.attr("dx",-1)
.attr("text-anchor","end")
.text(String);
// create x-axis ticks
chart.selectAll("line.vrule")
.data(years)
.enter().append("svg:line")
.attr("class","vrule")
.attr("y1",h+10)
.attr("y2",0)
.attr("x1",function(d) { return (d-byear)*w*12 + 20; })
.attr("x2",function(d) { return (d-byear)*w*12 + 20; })
.attr("stroke","#ccc");
// label x-axis ticks
chart.selectAll("text.vrule")
.data(years)
.enter().append("svg:text")
.attr("class","vrule")
.attr("y",h)
.attr("x",function(d) { return (d-byear) * w * 12 + w * 6 + 20; })
.attr("dy",10)
.attr("text-anchor","middle")
.text(String);
// create bars
var bars = chart.selectAll("rect")
.data(data)
.enter().append("svg:rect")
.attr("x", function(d, i) { return i * w + 20; })
.attr("y", function(d) { return h - y(d); })
.attr("width",w)
.attr("height", function(d) { return y(d); });
// create x-axis
chart.append("svg:line")
.attr("x1",20)
.attr("y1",h)
.attr("x2",totw+20)
.attr("y2",h-.5)
.attr("stroke","#000");
// create y-axis
chart.append("svg:line")
.attr("x1",20)
.attr("y1",h)
.attr("x2",20)
.attr("y2",0)
.attr("stroke","#000");
};
var parseCB = function(jsn) {
var idx, yr, mo,
byear=2005, eyear=2011,
months=(eyear-byear+1) * 12,
data=[];
for (var i=0; i < months; i+=1) { data[i] = 0 };
if ("investments" in jsn) {
for (var i in jsn["investments"]) {
var j = jsn["investments"][i];
if ("funding_round" in j) {
yr = j["funding_round"]["funded_year"];
mo = j["funding_round"]["funded_month"];
if (!yr || !mo || (mo == "None")) { continue };
idx = (parseInt(yr)-2005) * 12 + parseInt(mo) - 1;
if (idx < 0) { continue };
data[idx] +=1
};
};
};
return bchart(data,byear);
};
$(document).ready(function () {
$("a").click(function () {
var vc = $(this).attr("id");
$.getJSON("http://api.crunchbase.com/v/1/financial-organization/" + vc + ".js?callback=?",parseCB);
return;
});
});
Monday, August 1, 2011
Pace of VC investing by subsector
I couldn't sleep last night so I figured I'd see if I could confirm a nagging suspicion about the early-stage VCs I know. About six months ago it seemed like they were slowing down their pace of investing while the corporates and newer super-angels were doing a lot more deals. If this were true it would be an interesting warning sign.
So I downloaded d3.js, pulled out the list of VCs I put together for VCdelta and built a visualizer for Crunchbase data. It's fun to play with*.
Here's a graph of the deals the 150+ VCs have done since 2005, according to Crunchbase. If you go to the site and click "All" at the bottom, you get this, except it's live to add and subtract either VC firms or round types from and you can hover over the bars and see the names of the companies invested in that month**. You can also, if you click the subsets below, see who I included and who I didn't. And then add or subtract to your heart's content.
Here are all the VCs, but just the rounds tagged Seed, Angel and A.
New York City is on a roll, right? Right. Below are the NYC funds (not NYC deals) and how many early stage (Seed, Angel, A) deals they did.
Compare this to Sand Hill Road:
Sand Hill Road has remained relatively conservative into 2010 and 2011.
Some other VC subsets. I used the top 20 venture capitalists in Forbes' Midas List to create a 'smart money' subset of firms. Here are their early-stage deals. The pronounced uptick from the lows in 2008 and 2009 into 2010 and 2011 are heartening.
I also made a subset consisting of firms that have been around since before the 1980s, the 'old school.' I assumed that if they've made it this long, they must be doing something right. Their increase in early stage investments, while less pronounced, is also heartening.
Last, the Super Angels. No surprise here.
The one thing these graphs don't do is support my original thesis, VCs are not slowing down their funding of early-stage companies. Interestingly, I found that even the VCs who have flat-out told me they are slowing down their investing are not really doing so: while there's fear in the market, VCs are also clearly seeing opportunities they can't turn down.
-----
* d3.js is awesome. The Yieldbot guys turned me on to it. I'm just learning it, so I know I'm manhandling it something awful, but it's a joy to work with.
** Let's do the usual caveats: Crunchbase data sucks for this kind of thing. It's incomplete, it's biased, it's not very clean or accurate, etc. This is all completely offset by the fact that it's free. If I had a better dataset, I'd use it, but I don't.
Thursday, June 23, 2011
@VCdelta released. Whoops.
Josh Kopelman tweeted about my weekend project today, which is still in alpha (at best.) Until yesterday, the only follower was Dave McClure. But he follows so many accounts that I figured he just auto-followed anyone who tweeted '500 Startups.' I was going to wait until I got back from next week's vacation before mentioning it to anyone, but the twitter-feed is open, so... it's been released.
The website is the API: I wrote a script to look at the portfolio pages of VC websites every night and tweet and post new companies that seem to have been added. It's pretty useful in a way, but has some severe limitations.
The biggest is that scraping is inherently fragile. And I'm going on vacation next week and leaving the computer it's running on at home, running it. If it starts to spew garbage on Monday, well... sorry. I'll fix it when I get back.
It is reporting on differences. So when Stickybits changed to Turntable.fm, it showed that First Round added Turntable. When Tremor Media changed its name to Tremor Video, it got reported, etc.
VCs don't always update their portfolio pages in real-time. This is no substitute for Techcrunch (or Crunchbase, even), it's just faster and easier to scan. I've been adding the VCs in drips and drabs over the past few weeks, so there are certainly additions that got missed because of the timing. The web site is pretty cool, it lets you filter by name and date and sort. That will be more useful over time as more deals get added.
The list of VCs looked at is here. If I missed yours, let me know and I'll add it to the to-do list. Unless your site is in flash (cough, Norwest) or has no portfolio company names (ff Ventures, among several others) or doesn't allow bots (yes, oddly enough, there is a site that checks the user agent and sends my script a page with no real content; the robots.txt--as with all of the pages I look at--allows, but the server doesn't. Why?)
Enjoy.
Wednesday, June 8, 2011
The new adtech is disruptive, and that's a good thing
I was at Luma Partners' Digital Media Summit today. Great event, saw lots of familiar faces. I watched the adtech panel. Of the people I didn't get a chance to invest in, these are four of the smartest: Brian O'Kelley, Joe Apprendi, Michael Barrett, and Mike Leo.
Mike Leo said something that struck me as wrong. He said, roughly, "30% of the media spend is getting spent on the pipes"--by which I think he meant the other panelists' companies--"and that's eating into the creative and the content, where it should be spent."
This is exactly the wrong way to look at it.
The entire process between the maker of a product or service and the user of that product or service--what we call marketing--is friction. This includes the pipes, the ads themselves, and even the content created to wrap the ads. Friction, all of it.
I agree that we should reduce the friction, make things more efficient. But if we give credit to Wanamaker's 50% waste in advertising spend, then the 30% that's now being spent on the "pipes" is a 40% improvement. A 40% improvement over five years is pretty spectacular. But disruptive technologies do that.
Leo is looking at the wrong place--he's complaining about the one area of the marketing process that has actually shown efficiency gains, while giving a pass to creative and content, the areas that have fallen behind.
Tuesday, June 7, 2011
Valuation for investors
Twice in the past week I have had pre-product entrepreneurs tell me that they were raising seed rounds at an approximately $10mm pre-money. In both cases I had to pass, despite the merit of the management teams. Both companies told me that they have other early-stage investors ready to fill their rounds, and I'm glad. I am generally of the opinion that if an entrepreneur can get a better valuation while still getting value-add investors, then they should.
Plenty has been written recently by venture capitalists about venture capital to help entrepreneurs. Not much has been written to help newer venture capitalists. I think, in a way, this is because VCs don't care so much if those new to the industry succeed or not. If a new angel loses his shirt, well, one less competitor for me down the line.
I don't believe that, though. I think we need more investors. But smart ones, investors who make some money on their investments and so feel confident reinvesting it in a new round of entrepreneurs. Investors, like everyone else, get smarter and more helpful the more experience they have. Smarter investors is better for the ecosystem.
So, valuation.
Valuation in venture capital is tough. The amount of uncertainty between investment and exit is immense. But that doesn't mean that you shouldn't try to pay the right price. Valuing a startup correctly means estimating risk, not contemplating the unknowable. The idea that was briefly tossed around that valuation doesn't matter because a startup either goes big or dies is wrong. Ludicrous, in fact. There's a range of outcomes for every fund. The cliche that out of each ten investments, two are winners, three are failures and five go sideways shows this. The two winners determine whether the fund is an overall winner or loser, but how sideways the five go determines whether it's a good return or a great return. What happens to the second tier of investments matters. And, for the math challenged, even if startup returns were binary, when you invest in many of them you get a binomial distribution, so expected value matters.
I look at valuation this way. For every company,
- I think about what the expected exit would be if the entrepreneurs were right: if they are right about the problem, about what their customers want, about their ability to execute, right about everything.
- I figure out how much dilution I expect before the exit.
- I decide how likely it is they are right and multiply by the expected exit to get an expected value.
- I divide by three, because I'd like my investments as a whole to return 3x*.
This is the post-money valuation.
An example. Company X is an amazing data-driven adtech company. It's going to disrupt some existing companies and if it does it should sell for $400mm in five years. I think, given the risks, that there's a one in ten chance they will succeed.
But I know they will need to raise a Series A to commercialize the product once it's ready, and a Series B to ramp sales once they have product-market fit, and a Series C to expand the product line. The Series A will be 33% of the company, the Series B will be 25%, and the Series C 20%. My stake will be diluted down to 40% of my original ownership.
So my post-money expected value of the company is $400mm * 10% * 40% = $16mm. I would be looking for a post-money of $5mm. If the company is raising $1mm in the seed round, the pre-money valuation would be $4mm.
You can see the difficulty in the $10mm pre-money. If the company is raising, say, $2mm at a $10mm pre, then the expected exit value would have to be $12mm/(10% * 40%) * 3 = $900mm.
Billion dollar exits are the sine qua non of the venture business. But they are rare. Rarer than you think.
I made a list off the top of my head of some 125 business-to-business advertising exits. I may be missing some obvious ones, but there were only a handful of $500mm plus exits in the last ten years, even fewer billion dollar ones (M&A exits, I didn't count IPOs, so I probably undercounted by one or two.) Here are the $500 million and up exits I have.
| Company | Acquiror | Price ($mm) | Date |
| aQuantive | Microsoft | $5,900 | May-07 |
| Doubleclick | $3,100 | Apr-07 | |
| Omniture | Adobe | $1,800 | Sep-09 |
| Overture | Yahoo! | $1,630 | Jul-03 |
| Digitas | Publicis | $1,300 | Dec-06 |
| NetRatings | Nielsen | $817 | Feb-07 |
| AdMob | $750 | Nov-09 | |
| Right Media | Yahoo! | $680 | Jul-07 |
| Lending Tree | IAC | $675 | Aug-03 |
| 24/7 Real Media | WPP | $650 | May-07 |
| Rosetta | Publicis | $575 | May-11 |
| Razorfish | Publicis | $530 | Aug-09 |
Of the 125 exits, five were more than a billion, seven were between $500 million and a billion, 20 were between $200 million and $500 million, and 15 were between $100 million and $200 million. The rest were sub-$100 million. Remember, these were all exits--companies that didn't make it weren't counted. There's also a bias in the list because I am more aware of the large exits; I would be surprised if I missed too many billion dollar exits but I am sure I missed many $10mm exits. Also note that only a couple of the billion dollar exits here were as straightforward as my model: aQuantive was built through acquisition (and thus had substantially more dilution), Doubleclick had gone through several owners including the public markets, etc.
In fact, all else being equal (a priori, that is) billion dollar exits returned less overall than $500mm-$1bn exits, because there were fewer of them. Exits between $200mm and $500mm probably returned slightly more than $500mm-$1bn exits (also because there were more of them). The $100mm-$200mm range and less than $100mm range each return less than the $200mm-$500mm range**. Here's my estimate of what each of these ranges returned.
| Exit Range | Companies | Total Est. Value |
| $1bn + | 2 | $3,000 |
| $500mm - $1bn | 7 | $5,000 |
| $200mm - $500mm | 15 | $6,000 |
| $100mm - $200mm | 25 | $4,000 |
| $50mm - $100mm | 50 | $3,750 |
| < $50mm | 100 | $2,500 |
The sweet spot in adtech, the "average" expected exit value, seems to be around $400mm.
Every industry is different, you need to know yours. Make a list of exits over the last ten years, all exits not just the good ones. Then try and figure out how many companies were funded in your industry. This will inform your expected exit values in the success case as well as help you decide what percentage of funded firms get to an exit. Conditions change all the time, of course, but looking at the last ten years will probably keep you reasonably conservative.
-----
* I asked an engineer friend of mine how comfortable he is being in the buildings he helped design. "Pretty comfortable", he said. "You never worry?" I asked. "Look", he said, "There's a lot of math and experience behind choosing exactly how much steel and concrete the building needs to bear its load. I do the work carefully, run the calculations twice and make absolutely sure the answer I am getting is the right one. Then I multiply by three." [Edit: For those for whom anecdote is not analysis, I'll point out that a 25% IRR compounded annually for five years is 3x].
** The list I made is up here. Click on the headers to sort. I think all of the #N/As are sub $50mm exits except the two bolded ones, which I think are ~$200mm exits. [Edit: Wow, the sorting on the linked table was all screwy. Sorry. Fixed it.]
Monday, June 6, 2011
On failing
Don't confront me with my failures, I have not forgotten them.
- These Days, J. Browne
Six years ago. I was working on a startup with a bunch of friends, a big idea and one that got me out of bed every morning, excited to go to work. We had raised money from a Name and some amazing venture investors. We were going to be the next Google. My other gig, a venture fund, had just had the exit that put it over the top: one of the portfolio companies had gone public. Me and my two partners--one active and one silent--had made the fund back and then some. I was going to make more than living wage from the eight years of work that portfolio represented. At home, we had finished furnishing the house, our third child was on the way, and my roses were finally getting some traction.
I was out with a good friend recently. He told me an old college buddy of ours was having some trouble with his career, with his marriage. I'll call him, I said, I should talk to him. No, my friend said, he doesn't want to talk to you right now. He thinks you wouldn't understand. Everything's always worked for you.
Five years ago. Our Name investor had realized that if we stopped trying to grow the business, it would immediately begin making money. This was not what we wanted, we wanted to be the next Google, not a tiny mortgage lead generator. But he wasn't a venture guy, he wasn't an investor at all, he was a buyer of assets. He scared away the outside money, starved the business of cash, and forced us to accept a buyout. I had been pushed out of the company I had helped start. In the entrepreneurial community, there aren't many marks blacker than that.
Meanwhile, my active partner in the venture fund decided that the silent partner should not be paid their share of the fund, contrary to what our contract seemed to my non-lawyer eyes to say, and certainly contrary to what fairness dictated. When I refused to go along with that, he sued me. He also sued the silent partner. The silent partner fought back, and the whole kit-and-kaboodle got locked down. The vast majority of my assets were frozen, being held hostage to some ridiculous legal squabble for some indeterminate period of time.
Not entirely coincidentally, my marriage fell apart at that exact moment.
I had failed, utterly. I had no job, my net liquid assets were approximately zero, my reputation was in tatters, and the one thing in my life I thought was permanent was over. The struts that supported my sense of self all got knocked out pretty much simultaneously. Everything I had, everything I hoped for. Five years ago, today.
In what way are you the same person today that you were twenty years ago? There is no atom of matter in you that was there twenty years ago, there is no piece of you that is the same as it was. The pieces of you, the functioning of you, the pattern of you are all different. Why are you you? What is you? What is it that continues? When the Buddha told us to meditate on death this is the question he wanted us to ask ourselves: what where you before you were born, what are you after you die? In what way are you still you even twenty minutes from now?
I'll tell you an answer, although me telling you no more gives you wisdom than reading a cookbook gives you nourishment: we are a span of links in a chain of causality. My existence now causes my existence a minute from now, and that a minute from then. There is no me except my self causing my next self every tick of the clock. In consequence, I am subject to the Markov property: how I arrived at the current me is irrelevant, every option available to me is embodied in who I am now, not in how I got here.
I'm no saint and failure did a number on me. Someone told me what intense stress would do to my psyche, the stages of irrationality I would go through. Frustratingly, the knowledge of them did not allow me to avoid them. But failure taught me some humility, and being humble forced me to abandon the personas I had built and my arrogance of idealism. And I finally learned that except in how it hobbled me, my failure made no difference--all that mattered was what I did next.
Five years after everything fell apart I have the best portfolio of startup investments in one of the hottest spaces in tech. People I respect and admire recommend me to entrepreneurs. I am allowed to be productive. And I spent Memorial Day with my loved ones and was happy and relaxed and even looking forward to getting back to work after a long weekend. I appreciate it, all of it, every time. I haven't forgotten I had nothing. I take nothing for granted. But I don't now and never did believe that the past determines the future. The future is determined only by the choices you have now--the ones you can find a way to allow yourself--and what you do with them.
I don't think saying that everything's always worked for me is wholly accurate. But it may be that it is entirely true.
Subscribe to:
Posts (Atom)
Short 
Medium