Have you ever heard someone say “We raised 4mil A round at 20 pre”?
Like all trades, tech financing has its own vernacular. There is nothing you can’t figure out with basic math in the above quote. Soon, you as well can decode the crazy moon language spouted by entrepreneurs, investors & tech media.
Raising money from investors (VCs, angels, even friends & family) is always about two things:
This post will focus on the price of ownership bit. Also caveat lector: like snowflakes, the process of raising funds is unique, fragile and sometimes packed into a hard ball of ice which will give you a black eye. Every statement and example in this post has variations and exceptions.
Step 0 is to split initial ownership among the founders.
If you are a single founder, this step is quite easy. Most of our examples will use a 25⁄75 split between two cofounders, just to make the math interesting.
If you raise a seed round in Silicon Valley, odds are that you are getting money from Angels. Odds also are high that using something called a convertible note.
This means that the angels are essentially loaning you money, and expect to be paid back when you raise a Series A in the form of Stock.
The thing about raising money is that you need a valuation. If you don’t know how much a company is worth, then people cannot buy shares. In the stock market, the buyer and seller agree to a price of some shares and multiply that by all outstanding shares and you have a simple calculation of the value of the company.
During the fundraising process, this is flipped around. The investors and the founders usually start with how much money the company wants to raise. Then they calculate the percentage ownership the investors get for fronting that money. The valuation is backed out those.
Founders want = 1 million VC wants = 20% ownership ownership calculation: --------------------------- founders | VCs | total 80% | 20% | 100% valuation calculation: --------------------------- founders | VCs | total 4MM | 1MM | 5MM
Back to convertible notes:
The problem, is that early, early seed stage companies cannot accurately set valuations. During the seed round, convertible notes allow angels and other early, early investors to give money to the company without setting a valuation. Basically, the angels are saying that “I will give you this money now, and later during your series A, when you do set a valuation, use that number to issue me the right number of shares.” In practice angels can get essentially bonus shares issued to them as a reward for taking higher risk that comes with investing so early. These bonus shares are usually done through caps or discounts, but for now, just be aware of the terms and their purpose.
So the typical Seed Round looks like this:
ownership calculation: ---------------------------- founders | Angels | total 100% | TBD | 100% valuation calculation: ---------------------------- TBD, but angels have put in $X in convertible notes
Here’s where things get fun. In our story, the founders are doing well. They raised money from angel investors, launched a product and got traction.
This is a story, so we skip the part about self-doubt, the valley of sorrow, the struggle to grow and the lack of communication and accusations of level of commitment between co-founders.
In our story, the founders started with a 75⁄25 split. Got 200k from angels & now want to raise 2 million dollars (2MM) in the form of a Series A.
We now have to get a little bit into the mechanics of ownership. Ownership is done through shares. In the simple case, your ownership is the number of shares you own divided by all outstanding shares. Fairly simple. Our founders originally issued 1 million shares, so Founder A, got 750,000 shares and Founder B got 250,000 shares.
Initial ownership calculation: ------------------------------ founders | total 1MM | 1MM Series A ownership calc (in shares): ----------------------------------- founders | Series A | total 1MM | TBD | 1MM + TBD
If the Series A investors and the founders agree to give up 20% of the company for the 2MM dollars, then we can start filling in the table:
Series A ownership calc (in shares): ----------------------------------- founders | Series A | total 1MM | TBD | 1MM + TBD Series A ownership calc (in %): ------------------------------ founders | Series A | total 80% | 20% | 100%
At this point, basic algebra kicks in, just solve for TBD:
Series A ownership calc (in shares): ----------------------------------- founders | Series A | total 1MM | 250k | 1.25MM
Also, at this point, we calculate the price of a share. The VC’s paid 2MM and got 250k shares: 1 share is 2MM/250k or 8 dollars a share.
Series A ownership calc (in shares,%): ----------------------------------- founders | Series A | total 1MM | 250k | 1.25MM 80% | 20% | 100%
What about the Angels? Normally they would get their own column, but Here, the angels got rolled up into the Series A. In our example, the Angels got a discount on their price of their shares of 50%. That means, they were able to buy shares at 4 dollars a share. Their original convertible note is now magically transformed into 50,000 shares. For the sake of the simplifying the math, assume that 50k of the 250k Series A shares belong the angels above.
We also see that there are 1.25 million shares outstanding, worth 8 dollars a share. Simple math gets us a total company post-money valuation of 10 million dollars.
Since the founders raised 2MM, the pre-money valuation is 8MM.
The simple formula works like this:
pre-money val + size of round = post-money val
It’s really simple but
The real fun comes with Series B. We two basic ways things can go from here: better or worse. In the case of better, The founders can raise more money at a higher price, (an up round). In the case of worse, the founders raise more money at a lower price (a down round).
Let’s be optimistic: The founders are doing very well. They’ve got product market fit, and good cash flow and now want to raise 20 million dollars to accelerate the business. Time for a Series B.
Series A ownership calc (in shares,%): ----------------------------------- founders | Series A | Series B | total 1MM | 250k | TBD | 1.25MM + TBD ??? | ??? | ??? | 100%
The math is similar, but we have a reference point.
In this round, the founders and Series B investors have agreed that the company is doing well and worth much more than before.
When a startup is doing well, the Series B is usually made up all of the Series A investors plus some new ones.
In this case, the founders and investors have agreed to a 20 million round at a pre-money valuation of 180 million dollars.
Our post money valuation is 200 million dollars. It also means that the Series B investors have 10% of the company:
Series B ownership calc (in shares,%): ----------------------------------- founders | Series A | Series B | total 1MM | 250k | TBD | 1.25MM + TBD ??? | ??? | 10% | 100%
To solve for TBD, we know that 1.25MM/TBD = 90%/10% TBD resolves to 138,888 shares at 144 dollars per share. At this point, we can use algebra to solve for ???
Series B ownership calc (in shares,%): ----------------------------------- founders | Series A | Series B | total 1MM | 250k | 139k | 1.39MM 72% | 18% | 10% | 100%
One more quick term: dilution
See how the founders % of ownership drops at each round? That’s called dilution. When you join a startup and have X%, you have to expect your % to go down. This is okay, though because the shares you owned are essentially worthless the day you start the company. But after every up round, they are worth more. In our fictitious case here, the price per share went from 0 to 8 to 144. Dilution is no fun, but also can’t be avoided.
In our optimistic example, we saw an up round. What about a down round?
Imagine our founders have not quite yet nailed product-market fit or are trying to add a bit more features to reach critical mindshare or need an influx of funds to finally do a huge marketing push. As long as the investors believe in you, you are okay.
If the investors have lost faith, you might be in trouble. A down round looks like this:
Instead of a humongous 200MM post-money valuation, you get a much smaller X valuation and are only able to raise 5MM of the 20 you wanted. Further more, that 5 MM is at 2 dollar per share. That means the Series B team bought two thirds of the company (5MM/2 = 2.5MM):
Series A ownership calc (in shares, ~%): ----------------------------------- founders | Series A | Series B | total 1MM | 250k | 2.5MM | 3.75MM 27% | 7% | 66% | 100%
at 4 dollars per share, the new post-money valuation of company is 4 * 2.5MM or 10 million dollars.
Also, notice how much more severe the dilution is during a down round. Your pride and joy and blood and sweat and tears just got gobbled up. Furthermore in the event of an exit, your personal stake is cut sharply.
Nobody (not even the investors) like down rounds.
There’s one last variation called an even round. Those aren’t great, but they are better than down rounds.
Series C works just like Series B. So does D-Z.
On last point. That table we made above? It’s called a cap table. It’s usually a rather unremarkable excel spreadsheet, that investors and founders have been fighting over for months.
These are fictitious examples with numbers pulled out of thin air for the purpose of education. No founders or investors were harmed in the authoring of this post.
Do you want a real education? Go buy this book: Venture Deals: Be Smarter Than Your Lawyer and Venture Capitalist
Let’s revisit our pithy lead: “We raised 4mil A round at 20 pre”
Now you know that 20MM pre-money + 4MM round = 24 MM post money valuation. The series A investors got 17% of the company and the founders and seed/angels got the rest.
Concepts you should have learned:
There are tons of Software as a Service apps out in the world. A big part of the reason is that the math of SaaS apps allows for single founders or small teams to achieve livable wages with low risk.
How achievable? If your SaaS app solves a business need or produces some desired outcome, and you charge an average of US $60 a month, you only need ~150 customers to break 6 figures in annual revenue. 150 customers is small enough that you can almost brute force a customer base with old-school tactics like trolling niche meetups and even cold-calling customers to setup demos.
So, if you don’t want to try your hand in the App Store Casino or the Build-The-Next-Instagram Lottery, but you also don’t want to work for the Man/Woman, SaaS is a fairly well-trodden path.
However, SaaS means less risk, not riskless. Where does SaaS break down? First, it’s got a potentially painful, long, and shallow growth curve. This was masterfully described by Gail Goodman in her talk, The Long, Slow SaaS Ramp of Death (my notes here)
Small team SaaS apps have the usual problems, such as being responsible for the customer development, product sales, and marketing, despite the fact that you may only be a domain expert in one or two of the three. This is one of the biggest problems with SaaS, especially in the early stages of development when there isn’t much cash flow.
With a SaaS app, the more cash you have, the more your options open up. You can spend cash on customer acquisition for long-term revenue bumps, or you can spend it on improving your product to help with customer retention.
In other words, working SaaS apps are magic green boxes that eat Cash and Time, and spit out more money.
Cash flow in a SaaS app, however, is incremental. Each new customer only gets you ~$60. The total lifetime value of the customer is locked up in the future.
The traditional workaround is to offer a month or two free if the customer pays for a year in advance. With annual prepay, each customer brings in ten times more delicious lucre than the otherwise incremental $60.
Now you have ten times as much cash to blow on customer acquisition, requested features, or that new ping pong table.
A more recent phenomenon I’ve seen in the wild is the notion of Product & Service Hybrid apps.
PaSH: Product & Service Hybrid
In this case, we are talking about:
The typical PaSH app can be thought of as a SaaS app with a micro-consultant add-on to help you leverage the SaaS app.
For example, Optimization Robot is an upcoming combination AB testing platform and set of experts to help you run tests, suggest new tests, and monitor the results. Lead Genius is a combination of lead gen lists as well as lead gen army. Churn Buster is a combination of email dunning as well as humans who call expired accounts. No SaaS app can compete with voices on the phone.
The more traditional path is to actually come about it the other way. Starting with a consulting service and adding product over time. Copy Hackers might be the epitome of this, productizing their consulting w/ ebooks, videos, courses, and more.
If you’ve been reading closely, the Long, Slow Ramp Of Death refers to the slow wind-up times that SaaS apps typically run into.
PaSH apps always have the option to charge for the service component. The basic premise is that the service component delivers more value than just the monthly cost of the product, but costs less than an equivalent consultant or contractor. This can lead to large cash flow spikes and incremental monthly revenue much higher than the $60 you could charge for a code-only solution.
This potentially allows you to ride out the most grueling part of the ramp. Even one or two service add-ons might mean the difference between crashing into the end of the runway versus achieving takeoff velocity.
You will still have the awkward points while your customer count is <= 10, or when you start thinking about your first hire. PaSH is more risk mitigation and less sparkling, magical, silver bullet.
The Service part doesn’t have to be ongoing nor does it even have to have an explicit cost. The term “concierge service” is making the rounds and can have a measurable effect on customer acquisition and churn rate. Drip does this very well, and their concierge service is free as in beer, but awesome as in customer experience.
Lastly, despite being an unemotional husk, even I won’t discount the value of human contact with your customer. If you or your workers spend any time interacting with users, that’s the perfect opportunity to build trust, discover desired outcomes, and ultimately turn customers into advocates.
In the early days of a product, think of PaSH as life-support/plan B.
As your business evolves and matures, you should also be evolving the service component as well. One common direction is that the service component becomes less high-touch one-off, and a bit more scalable maintenance type work. Ideally, it evolves into an ongoing thing that benefits both parties. The SaaS operator gets higher monthly revenue and the customer reaps the benefits of improved business outcomes without the hassle of a W-2 or W-9 form. You want the customer to be thinking: “really, really inexpensive/highly optimized out-sourcing.”
At the end of the day, your options are not limited to the typical indie playbook of contractor moving into download or SaaS product. As long as you have customers who value business outcomes, a hybrid product/service is a potentially less perilous option.
Thanks to Micheal Buckbee, Tim Cull, Andrew Culver, Aaron Francis, Jeffrey Abbott for reading drafts & providing feedback.
So I’m a loyal acolyte in the church of docker. I also have this little schoolgirl crush on PostgreSQL. Here’s how you can combine both into a crime-fighting dream team.
Spin up a container, install a text editor and snapshot an image:
sudo docker run -i -t ubuntu:precise /bin/bash
Inside the container install a text editor (because the default
precise image doesn’t come with one installed):
apt-get update apt-get install vim-tiny exit
Snap an image. Your name is probably not amattn, however just for a moment, pretend otherwise. I know it is unpleasant, but only for a short while. I called my image
precise-vim but you can call it dinglemuffin if you really want to.
sudo docker commit CONTAINER_ID amattn/precise-vim
Again with the spinning up of a new container:
sudo docker run -i -t amattn/precise-vim /bin/bash
Do the basic install. The assist with the repo info is credited to https://wiki.postgresql.org/wiki/Apt
apt-get update apt-get install -y wget wget -O - http://apt.postgresql.org/pub/repos/apt/ACCC4CF8.asc | apt-key add - echo "deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main" > /etc/apt/sources.list.d/pgdg.list apt-get update apt-get install -y postgresql-9.3 postgresql-client-9.3 postgresql-contrib-9.3 exit
Again with the snapping of an image. Just a note here, I got odd failures when my image names had capital letters (as of docker 0.6.1).
sudo docker commit CONTAINER_ID amattn/postgresql-9.3.0
You can list all containers with
docker ps -a We don’t actually need the containers that we used to create images. Once we have images, we simply spin up totally new containers, while the sad, lonely ones we used to create the images get rm’d.
sudo docker rm CONTAINER_ID CONTAINER_ID ... CONTAINER_ID
Here’s the magic part. We want to configure PostgreSQL to put its data in the container’s a directory at the root level called
/data. This folder is shared with the docker host. This way, we can use any container configured to look at
/data with a persistent file on the host. Our data becomes decoupled from our container. In this example we use
$HOME/postgresdata, but feel free mount any host directory you like.
mkdir -p $HOME/postgresdata sudo docker run -v="$HOME/postgresdata":"/data" -i -t -p 5432 amattn/postgresql-9.3.0 /bin/bash
First setup our
cp /etc/postgresql/9.3/main/postgresql.conf /data/postgresql.conf cp /etc/postgresql/9.3/main/pg_hba.conf /data/pg_hba.conf
Use our custom data directory (
sed -i '/^data_directory*/ s|/var/lib/postgresql/9.3/main|/data/main|' /data/postgresql.conf sed -i '/^hba_file*/ s|/etc/postgresql/9.3/main/pg_hba.conf|/data/pg_hba.conf|' /data/postgresql.conf
/data/main/ and fill it with stuff.
mkdir -p /data/main chown postgres /data/* chgrp postgres /data/* chmod 700 /data/main su postgres --command "/usr/lib/postgresql/9.3/bin/initdb -D /data/main" cp /postgresql.conf /data/postgresql.conf cp /pg_hba.conf /data/pg_hba.conf
If you want to allow access from any ip address, the next three commands are for you. This is obviously a huge security risk, especially if you don’t have a firewall or similar in place. Caveat Developor
sed -i "/^#listen_addresses/i listen_addresses='*'" /data/postgresql.conf sed -i "/^# DO NOT DISABLE\!/i # Allow access from any IP address" /data/pg_hba.conf sed -i "/^# DO NOT DISABLE\!/i host all all 0.0.0.0/0 md5\n\n\n" /data/pg_hba.conf
su postgres --command "/usr/lib/postgresql/9.3/bin/postgres -D /data/main -c config_file=/data/postgresql.conf" & # As the user postgres, create a user named docker su postgres --command 'createuser -P -d -r -s docker' # As the user postgres, create a db docker owned by postgres user docker su postgres --command 'createdb -O docker docker'
su postgres --command '/usr/lib/postgresql/9.3/bin/pg_ctl --pgdata=/data/main stop' exit
Now we commit, but we should use a tag! Until now, all our commits are for general purpose containers. Even though all data and configuration is “outside” the container, we still want to be able to identify for what purpose a container exists. As of this writing, tags are the best way to do so.
sudo docker commit CONTAINER_ID amattn/postgresql-9.3.0 TAGNAME
I’ve found that tags in the format of
amattn/component:appname work very well in practice:
amattn/postgres-9.2.1:favstarclone amattn/postgres-9.3.0:flickrclone amattn/mariadb-55:bookmarker amattn/redis-2.6.16:bookmarker
The tags also help us remember not to delete those containers.
Launch the container with the
run command. Notice that we aren’t spinning up a shell anymore. We are launching a container w/ the tag
TAGNAME, running a single process (postgres) as the user postgres, with a random port forwarded to the container’s port 5432 and a directory mounted to the container’s
sudo docker run -v="$HOME/postgresdata":"/data" -d -p 5432 amattn/postgresql-9.3.0:TAGNAME su postgres --command "/usr/lib/postgresql/9.3/bin/postgres -D /data/main -c config_file=/data/postgresql.conf"
At this point, the container should be humming along in the background. You can even prove it to your disbelieving self with the
ps command. In particular, the status column should list an uptime and not an exit code:
docker ps -a
Start and stop the container with:
sudo docker stop CONTAINER_ID sudo docker start CONTAINER_ID
Get the host port with either of:
sudo docker ps -a sudo docker port CONTAINER_ID
In the host:
mkdir -p $HOME/postgresdata sudo docker run -v="$HOME/postgresdata":"/data" -i -t -p 5432 amattn/postgresql-9.3.0 /bin/bash
Inside the container:
cp /etc/postgresql/9.3/main/postgresql.conf /data/postgresql.conf cp /etc/postgresql/9.3/main/pg_hba.conf /data/pg_hba.conf sed -i '/^data_directory*/ s|/var/lib/postgresql/9.3/main|/data/main|' /data/postgresql.conf sed -i '/^hba_file*/ s|/etc/postgresql/9.3/main/pg_hba.conf|/data/pg_hba.conf|' /data/postgresql.conf mkdir -p /data/main chown postgres /data/* chgrp postgres /data/* chmod 700 /data/main su postgres --command "/usr/lib/postgresql/9.3/bin/initdb -D /data/main" # OPTIONAL: configure /data/postgresql.conf & /data/pg_hba.conf to allow access from trusted IP addresses # Start PostgreSQL su postgres --command "/usr/lib/postgresql/9.3/bin/postgres -D /data/main -c config_file=/data/postgresql.conf" & # OPTIONAL: add PostgreSQL user(s), go other setup config # Stop PostgreSQL su postgres --command '/usr/lib/postgresql/9.2/bin/pg_ctl --pgdata=/data/main stop' exit
Back in the host, optionally commit and tag. Launch the container with the
sudo docker run -v="$HOME/postgresdata":"/data" -d -p 5432 amattn/postgresql-9.3.0:OPTIONAL_TAGNAME su postgres --command "/usr/lib/postgresql/9.3/bin/postgres -D /data/main -c config_file=/data/postgresql.conf"
If you’ve every had the thought: “I know, I’ll make a SaaS product” then Gail Goodman’s 2012 talk on the Long Slow Saas Ramp of Death is for you.
Transcript and more here:
Here are my notes and summary of that presentation. Any errors are likely induced by me. I don’t know Gail, nor am I a customer of her company, but I loved this presentation.
The long, slow SaaS ramp of death is that it just takes a long time to get to minimum critical mass.
The basic premise is that you may never see hockey stick user growth, but with SaaS it might not matter. If your customers are saying you have something and you have some growth, then over time (possibly a long and challenging time), the math of SaaS usually works out in your favor.
Another initial point she made was to think of SaaS as more like a flywheel than hockey stick.
Don’t fall for the mirages. There are lots of different components that seem like they will boost you to some next level (partners, new feature, free, viral, seo, etc). Rather, your mindset should be more like SW development in that there is no silver bullet. No one event or feature will induce hockey stick growth, instead you will end up working on a thousand cumulative optimizations.
(08:40) Instead, you have to work the funnel by
… making sure that when someone tries or buys your product, they have a ‘wow’ experience, they get quick to an understanding and an outcome that blows them away.
(12:22) “I would argue that most of those little things will happen if you continue to view your business from your customer or user inward rather than from the metrics you want to change outward.”
Try to optimize the customer outcomes first. Spending significant time optimizing your landing page before nailing a feature set that delivers value is an inversion of the process.
(12:40) “The key to changing those internal metrics (funnel), is by starting with the view from your customer looking at your business and your experience. Not by looking at your metrics & trying to change your customer’s behavior.”
Sone solutions were decidedly old fashioned. Radio and free seminars worked for Constant Contact because small business owners often have radios on during the work day.
At the top of the funnel (landing pages, ad buys, etc.): Test, Scale, Tune & repeat.
Try Understand why customers weren’t flocking to you.
(22:35) “Quick to Wow.”
It’s all about optimizing the quick to wow.
Turns out the number one way to get them to stay, is to get them successful early.
Human Nature: When faced with a learning curve, humans tend to learn just enough to get the job done, then stop learning. It is hard to get customers to look at new features.
(23:53) Middle & Bottom of the funnel: Measure, test repeat.
(25:00) Innovate everywhere. Not just on the tech side of the house.
(26:20) A simple formula for calculating LTV (Lifetime Value of a single customer). It’s one over your retention rate. In the case of Constant Contact, their average monthly retention is 2.2% a month. One over 2.2% is ~45 months.
As an aside, different industries and regions seem to have different acronyms for this concept. I’ve seen LTV, LCV, CLTV, CLV & LTCV.
Best blog post: David Skok: SaaS Metrics, A guide to measuring and improving what matters.
“Operating at cash level: Only eating what we were killing.”
All spare cash going into marketing spend because at that time, CAC (Customer Acquisition Cost) was ~300 and LTV as ~1650. we knew that we could turn down marketing and be instantly profitable. In other words the money generation machine was working at full capacity.
(30:50) Inflection point came at the time where the combination of understanding 1. 2. 3. all came together to the point where we were confident scaling the business:
If your customers are telling you you’ve got something and your metrics are continuously improving, stay on the long slow ramp of death. But if either of those aren’t true, it is probably time to parachute off.
“You shouldn’t have to build your own metrics anymore.”
And she save one other great nugget for the very end:
You don’t own the gas pedal on word of mouth. The best gas pedal is a great experience.
Most of these rules are broken in the name of performance. Make sure the tradeoff is worth it. If you overcomplicate your architecture it means you will have more components where something can go wrong.
When building or replacing a component, the general rule of thumb is to plan for 2 orders of magnitude of growth. That gives you room to grow without over planning.
When choosing components to replace, you just find the bottleneck, widen and repeat.