Stock Dilution in a Startup

Let's say, for example, that you signed up to be COO of a startup company and the CEO founder offered you 5% of the company. The CEO says there's no funding in the bank yet, so you'll have to sign up for a low salary -- $50,000 per year.

But he assures you that he's had conversations with venture capitalists and there's a sense that if things go right, the company might one day sell for $100 million.

Hmmm, you think. 5% -- not bad. If we sell this thing for $100 million, I will walk away with $5 million.

WRONG!

Your math failed to take into account stock dilution. That's the effect the issuance of new equity shares has on the existing shareholders.

Let's go back to our example and see how stock dilution works in action.

You take the job and get 5% of the company.

Odds are you don't get it all at once -- it's probably subject to a vesting schedule and it might only be stock options -- but that's not really relevant to our equity dilution lesson.

How much is 5% of your pre-funding company worth?

Not much. In fact, until there's a funding round you don't really know what it's worth.

A funding round is important to entrepreneurs and their employees because it's a milestone that values the underlying stock of the company.

So, let's say that a year after you've been working as the COO of the company, you and the CEO are finally able to land a funding round.

The funders says they will give you $700,000 in capital for 35% of the company.

What exactly does that mean?

It means that the total valuation of the company after they put their money in will be equal to $700,000/.35, or $2,000,000.

In VC terminology, that's the post-money valuation. The pre-money valuation is therefore $1,300,000. That's the post-money valuation minus the value of the cash that is coming into the business as part of the funding round.

So, after the funding round, the valuation is $2,000,000 and you had 5% equity in the company, so now you're equity stake is worth $100,000, right?

WRONG!

Equity dilution knocks down your percentage stake in the business.

Here's how equity dilution works in this scenario.

Let's say there were 1,000,000 issued shares prior to the funding round. In order for the new investors to get a 35% equity stake, they need to be issued new shares.

How many shares?

It's a simple algebra problem. Let x be the number of new shares that need to be issued. The equation becomes:

x / (1,000,000 + x) = .35

Solving for x implies that 538,462 new shares must be issued to the investors.

The math says that it should be 538,461.5 but there's no such thing as half a share so we round up. Believe me, investors won't round down. If there's something on the table to be taken, they will likely grab it.

So, now the total number of shares in the company is 1,538,462. What your percentage equity stake in the company?

Well, you were allocated 5% of the 1,000,000 shares so you had 50,000 equity shares before the funding round.

After the funding round, you still have 50,000 shares.

So, now, your diluted equity stake in the company is 50,000/1,538,462, or 3.25%.

How much is it worth?

The answer is simply .0325 x $2,000,000. That's your percentage equity stake times the post-money valuation. As it turns out, your stake is worth $65,000, not $100,000 as you might have thought.

If the company were to sell for $100 million now, after the first round of venture funding is in the bank, you 3.25% stake would be worth $3.25 million, not the $5 million you thought you'd get before you learned about equity dilution.

Notice that there was an easier way to figure out your post-dilution equity stake. You gave away 35% of the company in the financing round, so your 5% was knocked down by a .65 dilution factor -- that's what you got to keep, in effect. So, 5% times .065 gives you the 3.25%. It's the same answer, but it's a quick way of calculating the effect of dilution on your equity stake.

Mind you, this is just your first round of dilution. If the company has to do a second round and gives away 40% of the company to new investors, then you've got to knock your 3.25% equity stake down by a .60 dilution factor. After that second round, your ownership stake will be down to 1.95%.

Is that good or bad? It depends.

If the post-money valuation on the second financing round is $1 billion, your stake is only worth $19,500,000. Not bad!

If the post-money valuation on the second round is $2,500,000, then your equity stake is only worth $40,950. Given the salary cut you took to get in on the action for this startup, this is a pretty miserable scenario.

Adding insult to injury is the fact that your equity stake's valuation is not real -- it's just a paper value. In a startup company there's usually no liquidity unless there's an exit event of some kind -- for example, maybe the company goes public or the company is sold to an acquiring company. At that time, you finally get to know what your stock is really worth.

What's the moral of the story?

Well, for starters, you can see that somebody who doesn't understand equity dilution is going to be overly optimistic about their likely take in a startup. They may be more willing to take a lower salary than they should be, or more willing to take a lower equity stake than they should be.

Now that you understand equity dilution, you won't make that mistake. You'll properly evaluate potential outcomes and likely funding scenarios and their dilutionary effect on your stake.

Based on your equity dilution analysis, we hope you'll make smart decisions. Good luck!

Courtesy

What is Lua?

Lua, an extension programming language (a language for extending applications). It supports procedural languages by using powerful data description facilities.

What does extension programming language mean?

There is increasing demand for customizable applications. As applications became more complex, customization with simple parameters became impossible: users now want to make configuration decisions at execution time; users also want to write macros and scripts to increase productivity. In response to these needs, there is an important trend nowadays to split complex systems in two parts: kernel and configuration.

The kernel implements the basic classes and objects of the system, and is usually written in a compiled, statically typed language, like C. The configuration part, usually written in an interpreted, flexible language, connects these classes and objects to give the final shape to the application.

Configuration languages come in several flavors, ranging from

a. simple languages for selecting preferences usually implemented as parameter lists in command lines or

b. as variable-value pairs read from configuration files (Windows .ini files, X11 resource files) or

c. as embedded languages, for extending applications with user defined functions based on primitives provided by the applications. Embedded languages can be quite powerful, being sometimes simplified variants of mainstream programming languages such as C.

Such configuration languages are also called extension languages, since they allow the extension of the basic kernel semantics with new, user defined capabilities. Lua is such a language.


What does powerful data description facilities mean?

Associative arrays are a powerful language construct for describing data used in an application.
Many algorithms are simplified to the point of triviality because the required data structures and algorithms for searching them are implicitly provided by the language.

Lua uses tabled for data description. Most typical data containers, like ordinary arrays, sets, bags, and symbol tables, can be directly implemented by tables.

Tables can also simulate records by simply using field names as indices. Lua supports this representation by providing a.name as syntactic sugar for a["name"].

Lua provides a number of interesting ways for creating a table. The simplest form is the expression {}, which returns a new empty table. A more descriptive way, which creates a table and initializes some fields, is shown below; the syntax is somewhat inspired in the BibTeX [13] database format:

      window1 = {x = 200, y = 300, foreground = "blue"}

This command creates a table, initializes its fields x, y, and foreground, and assigns it to the variable window1. Note that tables need not be homogeneous; they can simultaneously store values of all types.

A similar syntax can be used to create lists:

      colors = {"blue", "yellow", "red", "green", "black"}

This statement is equivalent to:

      colors = {}
     colors[1] = "blue";  colors[2] = "yellow"; colors[3] = "red"
     colors[4] = "green"; colors[5] = "black"

Sometimes, more powerful construction facilities are needed. Instead of trying to provide everything, Lua provides a simple constructor mechanism. Constructors are written name{...}, which is just syntactic sugar for name({...}). Thus, with a constructor, a table is created, initialized, and passed as parameter to a function. This function can do whatever initialization is needed, such as (dynamic) type checking, initialization of absent fields, and auxiliary data structures update, even in the host program. Typically, the constructor function is pre-defined, in C or in Lua, and often configuration users are not aware that the constructor is a function; they simply write something like:

      window1 = Window{ x = 200, y = 300, foreground = "blue" }

and think about ``windows'' and other high level abstractions. Thus, although Lua is dynamically typed, it provides user controlled type constructors.

Because constructors are expressions, they can be nested to describe more complex structures in a declarative style, as in the code below:

      d = dialog{
                hbox{
                     button{ label = "ok" },
                     button{ label = "cancel" }
                }
         }

What makes extension languages different?
They only work embedded in a host client, called the host program. Moreover, the host program can usually provide domain-specific extensions to customize the embedded language for its own purposes, typically by providing higher level abstractions. For this, an embedded language has both a syntax for its own programs and an application program interface (API) for communicating with hosts. Unlike simpler configuration languages, which are used to supply parameter values and sequences of actions to hosts, there is a two-way communication between embedded languages and host programs.

What are the requirements of extension languages?

• extension languages need good data description facilities, since they are frequently used as configuration languages;
• extension languages should have a clear and simple syntax, because their main users are not professional programmers;
• extension languages should be small, and have a small implementation. Otherwise, the cost of adding the library to an application may be too high;
• extension languages are not for writing large pieces of software, with hundreds of thousands lines. Therefore, mechanisms for supporting programming-in-the large, like static type checking, information hiding, and exception handling, are not essential;
• finally, extension languages should also be extensible. Unlike conventional languages, extension languages are used in a very high abstraction level, adequate for interfacing with users in quite diverse domains.

How does Lua become extensible?

In its design, the addition of many different features has been replaced by the creation of a few meta mechanisms that allow programmers to implement those features themselves. These meta mechanisms are: dynamic associative arrays, reflexive facilities, and fallbacks.

Dynamic associative arrays directly implement a multitude of data types, like ordinary arrays, records, sets, and bags. They also lever the data description power of the language, by means of constructors.

Reflexive facilities allow the creation of highly polymorphic parts. Persistence and multiple name spaces are examples of features not directly present in Lua, but that can be easily implemented in Lua itself using reflexive facilities.

Finally, although Lua has a fixed syntax, fallbacks can extend the meaning of many syntactical constructions. For instance, fallbacks can be used to implement different kinds of inheritance, a feature not present in Lua.

Where can we use Lua?
Currently, Lua is being extensively used in production for several tasks, including user configuration, general-purpose data-entry, description of user interfaces, storage of structured graphical metafiles, and generic attribute configuration for finite element meshes.

It took me 1 Hour and 10 mins to write this up on Nov 20th 2007 (9:30 am - 10:40 am). Just after bi-weekly HDK meeting.

More Information

KPP Seminars Attended

March 2006 The sun should never set on your investments - A primer on International investing

July 19th 2006 What it takes to stay ahead of the market

Oct 11th 2006 Happy New Year! – Stocks and Sectors that should shine in 2007

Nov 2006 Politics and profits - The Presidential Cycle

March 21 2007 Tough times ahead? - Prospering in a shaky market

June 21 2007 Back to the Basics - Improving your analytical skills