TOUGH CROWD

Every year, thousands of entrepreneurs launch startups, aiming to make it big. This journey and the perils of failure have been interrogated from many angles, from making risky decisions to start the next iconic business to the demands of having your own startup. However, while the startup survival has been written about, how do these survival rates shake out when we look at empirical evidence? As it turns out, the U.S. Census Bureau collects data on business dynamics that can be used for survival analysis of firms and jobs.

In this tutorial, we build a series of functions in Python to better understand business survival across the United States. Kaplan-Meier Curves (KM Curves) are a product limit estimator that allows for calculation of survival of a defined cohort of businesses over time and are central to this tutorial. By comparing survival rates in various Metropolitan Statistical Areas (MSAs), we find regions that may fair far better in business survival than others.

GETTING STARTED:

In order to get started, we're going to first load in a series of Python packages that will allow us to build out a survival analysis:

• Basics
  • io. Provides the Python interfaces to stream handling.
  • requests. Allows Python to send 'organic, grassfed' HTTP
  • zipfile. Provides tools to create, read, write, append, and list a ZIP file
• Data
  • plotly. A data visualization library.
  • pandas. A library the allows for easy data manipulation and processing.

Loading up packages follows the usual routine. If you get an error for plotly.offline,make sure you pip install it."

Using these packages, we will build a series of convenient functions to:

• Extract data from the Business Dynamics API
• Process extracts into product limit estimates of survival
• Visualize KM Curves
• Calculate and compare five-year survival rates for MSAs with population > 250,000 people

EXTRACTING DATA VIA THE BUSINESS DYNAMICS API

First thing's first, we need a function to query the data we are interested in pulling from the API. We want this function to accept:

• an arbitrary metropolitan statistical area code,
• a dictionary of variables,
• a dictionary of parameters to filter the data,

The result of the function should be beautifully formatted data.

Let's call the dictionary of variables we are interested as var_dict. Each key in var_dict is a variable name accepted by the API, and each value is a more user friendly name we give to the variables. We also want to implement a dictionary of parameters we wish to filter on, which can be passed on to parameter params in get method of package requests.

The get_data function is shown below. A deeper dive into the API documentation can be found here.

Notice that the get_data function requires an msa_code, but how can we find that MSA code? Turns out the Census has a reference table (https://www2.census.gov/econ/susb/data/msa_codes_2012_to_2016.txt). Again, we use package request to get this data and read it as a pandas dataframe. Notice that we use package io in order to read it without downloading (e.g. into buffer).

After reading in the data, we only kept the metropolitan statistical area, and change the MSA name to the major city and state. Using this basic reference table, we can look up a metro area by name and obtain the MSA code.

CALCULATING + VISUALIZING SURVIVAL RATES (5-year period)

Statistical Primer

Before proceeding, we need to establish a basic framework for analyzing survival. KM Curves are a common approach for analying 'time to event' data, whether it's an engineering problem with infrastructure failure or a medical problem with mortality. The application concept is essentially for business survival.

In the absense of censorship, or the condition in which the value or state of an observation is only partially known (e.g. loss to follow up, or attrition, etc), a survival function is defined as the following:

$S(t) = \frac{n -d}{n}$

where t is the "survival time" or time to failure or event, n is the number of observations in a study cohort, and d is the number of failure or death events. The survival rate over a study period is estimated using a product limit:

$\hat S(t) = \prod\limits_{t_i

where $\hat S(t)$ is the survival probability of individuals at the end of the study period t, $n_i$ is the number of individuals or observations at risk prior to $t_i$, and $d_i$ is the number of failure events up to point i. Essentially, for the calculation procedure to derive the KM curve is as follows:

• Calculate the survival probability $S(t)$ for each equal time interval from $t_i$ to period
• For each time period $t_i$, take the product of all survival probabilities from $t_0$ to $t_i$
• Plot $\hat S(t)$ against time

Implementation

With this basic statistical base, we now can build out a basic analysis. From Section 1, we have the msa codes as well as a nifty get_data function to tap into the Census Bureau API. Now, we'll calculate and visualize the survival rates across US cities. To do so, we'll write a new function survival_rate that accepts the name of a major US city and a base year that is used to define a cohort. The result of all the calculations will be an interactive plot of the five-year survival rate. To provide more context about survival, survival will be calculated for firms (individual companies), establishments (locations at which business is conducted), and jobs.

Census Bureau API has limited number of calls for users without a key. Because we will make many calls to the API, you need to register a key here: http://api.census.gov/data/key_signup.html, and assign the value to variable api_key:

Function survival_rate for calculating and visualizing the survival rate is thus:

More on using plotly with python can be found here: https://plot.ly/python/

Using our new survival_rate function, we can effortlessly calculate and visualize the survival rate of any metropolitan statistical area in any year. For example, businesses that formed in 2006 in the Seattle metropolitan area experienced relatively gradual declining survival rates with a sharper decrease in 2008 to 2009, likely due to the financial crisis.

Or we can look at New York metropolitan area in 2009. Notice how employment diverges from firms and establishments, indicating that while some firms exited, the remaining firms grew and created more jobs.

Note that we have relaxed a fundamental assumption about KM Curves. In the strictest of implementations, KM Curves should not increase over time, but given that data was collected at the firm level, it is possible for employment to grow among surviving firms.

MAPPING SURVIVAL RATES

Business survival rates can go a long way for informing business siting decisions among other strategic considerations. But much of the value of survival rates is realized through comparisons between cities. In this next section, we extend the functions produced in Section 2 to incorporate geographic data.

Geographic coordinate data

To start, we can take advantage of rich geographic resources provided by the US Census Bureau. The geographic location (longitude/latitude) of metropolitan statistical areas can be found on https://www.census.gov/geo/maps-data/data/gazetteer2015.html, under \\"Core Based Statistical Areas\\". Using the URL for the zipfile (http://www2.census.gov/geo/docs/maps-data/data/gazetteer/2015_Gazetteer/2015_Gaz_cbsa_national.zip), we'll use requests to get the zipfile, use zipfile to unzip the file in memory, then use pandas to read 2015_Gaz_cbsa_national.txt.

Let's read in and clean the data:

Population estimates

The population data can be found at http://www.census.gov/popest/data/metro/totals/2015/files/CBSA-EST2015-alldata.csv. We'll read the .csv file directly using Pandas' read_csv, extract the CBSA and POPESTIMATE2015 fields, then relabel the two fields geoid and population, respectively. This will prepare the data in the right shape for merging with the geography file.

Merging

We now want to join the geographic location, population data, and the msa_code data. The geoid variable is the primary key that will allow merging to connect the geographic and population information with MSA name.

Calculating survival rates in bulk

Similar to the calculation of survival rate above, we can now iterate through all MSAs and calculate the survival rate of jobs and firms.

After we've captured all the MSA-level survival rates in df, we can now plot it on a map. But, as we know, maps that communicate clear insights are well-designed, considering interactive functionality, color schemes, labels, and scale.

We can design a color palette and associated intervals using fixed thresholds, but the downside of this method is that we have to manually set the values and we don't have a good handle on the sample size in each bucket.

Another way is using quantiles as threshold. To do so, we can specify cut offs at the following percentiles: 0.03, 0.1, 0.5, 0.9, 0.97. This is far more intuitive as we can more easily spot the MSAs that belong to the highest 3% or lowest 3%.

We can now use this function to plot our data on a map. First lets take a look at firms. We can see some interesting patterns here. For example, South East MSAs, namely those in Georgia and Florida have a lower than average survival rate, while the MSAs between Great Lakes and Northeast Megalopolis have a high survival rate.

When we look at the jobs these firms created, we can recongize changes in the pattern. For example, Washington DC and San Jose stand out with high job survival rates in the region, while Cedar Rapids and Fresno experienced among the lowest employment survival rates.