Product Roadmaps (and Product Managers) Discussion

Just listened to a good podcast from Janna Bastow on building product roadmaps. In 24 minutes, here is what you will here:

  • Start with what problem are you solving and for whom.
  • 2 sources of input for roadmap
    1. Top down product management: vision + objectives + big steps
    2. Bottom up approach: conversations with customers, team, competitors – in the trenches.
  • Challenge – dealing with tons of data from customer, prioritizing, and communicating
  • How to address getting input from the team into the product plan: product tree game
    • Innovation Games was the inspiration
    • Put people from multiple disciplines in a room and put a huge tree on the white board
      • Trunk represents the core – foundation
      • Infrastructure is represented by the roots.
      • Ideas are the branches.
      • Have a bunch of post it notes and put them on the tree
  • Separate release plan (2-4 weeks out) from roadmap to give you agility – roadmaps do not have dates.
  • 3-6 months out for roadmap is reasonable for an immature product; 2 weeks is sprint for them. 
  • Roadmap should not be a set of features; distill out the higher level meaning of the features into more meaningful themes.
  • Every product should have objectives and metrics – but how do you measure the effectiveness of a product manager? Who knows:)
  • Is the HIPPO hijacking the roadmap? Stakeholder management and saying no are critical skills for a product manager.
  • Who else is doing interesting work in the product management thought space? Nate Walkingshaw, CXO at Pluralsight

Getting NYC Taxi Data into Azure Data Lake

I wanted to get a meaningful dataset into Azure Data Lake so that I could test it out. I came across this article, that walks through using the NYC Taxi Dataset with Azure Data Lake:

The article kind of skips over the whole part of getting the dataset into Azure. Here is how I did it:

  • Spin up a VM on Azure
  • On Server Manager, click on Local Server, next to IE Enhanced Security Configuration click the On link, and at least set Admin to Off (or else you will have to click ok a dozen times a web page)
  • Download the files from the NYC Taxi Trip website to your VM
  • Install 7-Zip so that you can unzip the 7z files.
  • Because the files in the trip_data.7z file are larger than 2GB, you cannot upload them using the portal, and you need to use Powershell.
  • You need to install the Azure PowerShell Commandlets – look for the Windows Install link a bit down this page
  • You will probably need to restart the VM for the Azure commands to be available in PowerShell
  • Go wild on Azure Data Lake Store using this doc – here are the key steps:

 # Log in to your Azure account

# List all the subscriptions associated to your account

# Select a subscription
Set-AzureRmContext -SubscriptionId “xxx-xxx-xxx”

# Register for Azure Data Lake Store
Register-AzureRmResourceProvider -ProviderNamespace “Microsoft.DataLakeStore”

#Verify your ADL account name

#Figure out what folder to put the files
Get-AzureRmDataLakeStoreChildItem -AccountName mlspike -Path “/”

NOTE: if you do not want to copy the files one-by-one, you can just copy the whole folder using this format: Import-AzureRmDataLakeStoreItem -AccountName mlspike -Path “C:\Users\Taxi\Desktop\files2\trip_data” -Destination $myrootdir\TaxiDataFiles

Once you have the files uploaded to Azure Data Lake, you can delete the VM.

If you know of a faster way of getting them there (without downloading them to your local machine), I would love to hear it!



Startup Dilution Explained as Simply as Possible

I had the opportunity to run Microsoft Azure’s Startup Accelerator in 2013. For 2 programs, we helped about 10 startups accelerate their businesses during a 3-month startup boot camp. Since Azure was the sponsor, there was a bit of technology work done, but the biggest gains for the startups were: 1) in their understanding of their customer and their business model; and 2) in their understanding of the mechanics of startup funding. To this day, I still find dilution over several investment rounds to be one of the most super-complex and super-intriguing concept in the startup funding space.

Why Do We Need Dilution for Startup Fundraising?

Before jumping into the mechanics, let me ask you a question: why do we need to dilute investors at all? If you were only going to raise a single round of funding, you do not need to dilute investors at all. You would say “I will give you this much of my company in exchange for that much capital.” Eventually, you either will come to terms of selling X% of your asset for $Y, or you will not, but dilution does not enter the equation.

Dilution only becomes an issue when you are going to raise capital over multiple rounds.

Why Are Multiple Round Investments Required for Startups?

For simplicity’s sake, let’s assume you have a really clear capital requirements ($100,000 needed today, $200,000 needed in 12 months, and $300,000 needed 24 months), and the only unknown is valuation. Certainly it would be logically possible to raise all of the money ($600,000) today, but no investor would want to give you capital for a super-risky startup so that you could park most of the cash in a bank for a couple of years. So that is not a realistic option.

You could also agree on valuations today, and then collect the money in 12 and 24 months as it is needed. But what if the startup flounders for 12 months: are the investors still required to invest at the initially agreed upon valuation? If you give the investors an option to renegotiate because the startup is not “killing it,” then wouldn’t any rational investor argue for a lower valuation in 12 months so that could increase their equity for the same investment? Certainly, you could imagine a bunch of performance criteria and contractual provisions that would establish the future valuation, but given the unpredictable nature of a startup this would be an impossible task to do well.

Multiple Rounds & Dilution to the Rescue

“Let’s All Negotiate Timing, Capital to Raise, and Valuation at Each Round”

Because it is so difficult to foresee what is going to happen in terms of capital requirements and valuation with startups, raising multiple rounds of capital, and diluting founders and earlier stage investors with each round of funding, has become the norm.

Turning back to the scenario ($100,000 needed today, $200,000 needed in 12 months, and $300,000 needed  in 24 months), we establish a first round where we are just trying to raise $100,000. Back of the napkin, startup investors are going to want to acquire between 20% and 40% of the company for EVERY SINGLE ROUND OF INVESTMENT. The way to think of this is not that your company is worth $500,000 because you are raising $100,000, but that your company better be worth $500,000 if you hope to raise $100,000.

First Round: Founders Diluted by 1st Round Investors

Let’s keep the math simple and say: the startup has pre-money valuation of $400,000; we are raising $100,000; and this gives us a post-money valuation (pre-money valuation + amount raised this investment round) of $500,000. Investors will end up with 20% equity (amount raised from investors this round / post-money valuation, or $100,000/$500,000 = 20%). The founders ownership in the company is diluted by 20%, so that their initial ownership (100%) is diluted to 80% (100% * 80% = 80%…the math will get more interesting next round:).

Pre-Money Valuation  $400,000
Amount Raised  $100,000
Post-Money Valuation  $500,000
Founder Ownership 80%
Round 1 Investor Ownership 20%

Second Round: Founders and 1st Round Investors Diluted by 2nd Round Investors

Fast forward 12 months, and the business needs to raise $200,000. The 2nd round investors may be the same set of investors or a new set of investors. The math is easiest if you assume they are different (and if there is an overlapping investor, she will be entitled to the sum of their first and second round of equity).

Assuming that the second round of investors want to acquire 20% of the company, we will see dilution in action. The 2nd round investors will get 20% of the equity, leaving the founders and the 1st round investors with 80% of their original equity positions.

 Round 1  Round 2
Pre-Money Valuation  $400,000  $800,000
Amount Raised  $100,000  $200,000
Post-Money Valuation  $500,000  $1,000,000
Founder Equity 80% 64%
Round 1 Investor Equity 20% 16%
Round 2 Investor Equity 20%

This may seem like a bad outcome for the 1st round investors, because they have been diluted from 20% to 16%, but they are better off. Now they own 16% of a $1,000,000 asset (or $160,000) instead of 20% of a $500,000 asset (or $100,000). The key for the early stage investors is that the asset needs to be growing faster than they are being diluted (when the dilution exceeds the increase in valuation, so that the early investors are financially worse off, this is called a down-round, or a bummer).

Third Round: Founders, 1st & 2nd Round Investors Diluted by 3rd Round Investors

Another 12 months, and we need to raise another $300,000. You know the drill, so here is the table.

 Round 1  Round 2  Round 3
Pre-Money Valuation  $400,000  $800,000 $1,200,000
Amount Raised  $100,000  $200,000 $300,000
Post-Money Valuation  $500,000  $1,000,000 $1,200,000
Founder Equity 80% 64% 51%
Round 1 Investor Equity 20% 16% 13%
Round 2 Investor Equity 20% 16%
Round 3 Investor Equity 20%

Startup is Sold (Hooray!)

Let’s assume that a year after the last round, we sell the company for a cool $3 million dollars. The funds are distributed in accordance with their final round equity positions.

Round 3 Sale
Sale Price  $3,000,000
Founder Equity 51% Founder Payout  $1,536,000
Round 1 Investor Equity 13% 1st Round Payout  $384,000
Round 2 Investor Equity 16% 2nd Round Payout  $480,000
Round 3 Investor Equity 20% 3rd Payout  $600,000

Even though the Round 1 investors are heavily diluted, they end up with a 284% ROI (after invested $100,000), while the Round 3 investors had no dilution, but a “measly” 100% ROI.  There are differences in the time value of money (1st round investors have their money tied up for 3 years), but that does not cause the difference in return. The main reason that the early investors get outsized gains is because they took significant risk. As the startup becomes more mature, the odds of failure become less (even though they are still high) and the returns typically reflect this decrease in risk.

Dilution Mechanics: That Was Not So Bad

The mechanics of dilution are not too bad when you break them down as a simple math problem. Where it gets complicated is when you throw in reality: what are your actual capital requirements (amount and timing of cash required to grow your business), what valuation will maximize your startup’s overall probability of success (not just closing this round), which investors are going to be most helpful to your company (if you are lucky enough to be able to choose), and how much time should you invest hunting investors instead of generating non-dilutive capital (aka – customer revenue:).

I hope that you found this useful. If you have any questions, drop me a comment. Thanks, and good luck favorably diluting your early investors!



Quick Hit: Common Ways to Interact with Hadoop

MapReduce: geniuses only. If you are on this page, read the next option!

Pig: Short for Pig Latin. Allows you to query Hadoop like SQL. Developed by Yahoo. Easy to learn.

input_lines = LOAD '/tmp/my-copy-of-all-pages-on-internet' AS (line:chararray);
 -- Extract words from each line and put them into a pig bag
 -- datatype, then flatten the bag to get one word on each row
 words = FOREACH input_lines GENERATE FLATTEN(TOKENIZE(line)) AS word;
 -- filter out any words that are just white spaces
 filtered_words = FILTER words BY word MATCHES '\\w+';
 -- create a group for each word
 word_groups = GROUP filtered_words BY word;
 -- count the entries in each group
 word_count = FOREACH word_groups GENERATE COUNT(filtered_words) AS count, group AS word;
 -- order the records by count
 ordered_word_count = ORDER word_count BY count DESC;
 STORE ordered_word_count INTO '/tmp/number-of-words-on-internet';

Hive: originally built by Facebook, a social networking site (you knew you would learn something). It has a SQL-like language called HiveQL. The queries are translated into MapReduce, Tez, or Spark jobs.

2 CREATE TABLE docs (line STRING);
4 CREATE TABLE word_counts AS
5 SELECT word, count(1) AS count FROM
6  (SELECT explode(split(line, '\s')) AS word FROM docs) temp
7 GROUP BY word
8 ORDER BY word;

Oozie: an orchestration framework that allows you to string together different MapReduce, Pig, and Hive jobs.



Why does Google care so much about bounce rate?

Google significantly promotes this statistic – the bounce rate – making it available in most of its reports and even on the accounts overview page (the only other statistic shown is the number of sessions). Google focusing on bounce rate makes a bit of sense: Google sells recommendations for a living through its advertising platforms, and a high bounce rate means that it is doing a rotten job of matching consumer intent with the advertiser content.

So what is bounce rate?

Bounce rate measures the percentage of visitors who visit one and only one page of your website.

Single Page Visitors            Total Visitors – Multiple Page Visitors

————————-   =   ———————————————— = Bounce Rate

Total Visitors                                   Total Visitors


Why provide two very similar equations for bounce rate? I wanted to highlight the easiest way to improve your bounce rate: increase the number of multiple page visitors. Preventing visitors from bouncing is hard…you are trying to accomplish a negative. Getting visitors to visit a 2nd page is a lot more actionable. To improve your bounce rate, all you need to do is get more people to click on a second page. Read that one twice. Go find the pages that are causing most of your bounce problems and see whether you have made it appealing to visit a second page. Are there too many navigational elements? Are you providing your entire website on the page? Once you start thinking about how to get people to visit a 2nd page, you will find some easy ways to improve your bounce rate.

Are there better metrics?

You bet. Having a low bounce rate as a goal is like looking to purchase a car that does not explode: it is a good minimum standard, but you should aim higher. Ideally, your metrics will include a visitor purchase where money changes hands. But starting with measuring purchase activity may not provide enough insight in what is happening between that first visit and the eventual purchase. According to Google Analytics, 98% of visitors NEVER make a purchase, so figuring out where along the path customers are dropping off can help you identify were you should focus your efforts.

Why does Google obsess with bounce rate?

The genius of bounce rate is that it is the easiest “quality” metric to measure on the planet. There is no need to ask what a consumer actually wanted, or to ask an advertiser about its campaign goals. Bounce rate allows you to abstract away all of the complexity of a real-world business relationship and ask a simple question: did the visitor click on a link after following our recommendation to visit the site?

Businesses should take time to define more meaningful goals, and revisit their goals from time to time. Typical goals will include activation (e.g., visiting a certain number of pages, reading a white paper, revisiting the site), signup (e.g., for a newsletter, a trial, or a demo), and purchase.


Note: I published this article for Payboard a while back, and I am republishing it here since the Payboard blog is no more.

Skipping Over Quill Buttons with Tabs

I am a big fan of Quill. You can add it to your website, and in minutes have rich text capability (like adding links to the Quill website to your text).

I am also a big, dare I say HUGE fan of tabbing when I am filling out forms. By default, Quill controls (like bold, italic, link, etc) accept focus when you tab, so if a user is filling out and tabbing through a form, when they get to the rich text editor they have to (aaahh!) grab their mouse and navigate into the rich text box.

The short answer is to use jQuery to add a tabeindex -1 (do not allow tab focus) to every button within the .ql-toolbar class, like this:

$(“.ql-toolbar”).find(“:button”).attr(‘tabindex’, ‘-1’);

For good measure, here is the complete Quill code that I am using. It also handles tabbing out of the editor (so when you hit tab you go to the next field). Let me know if you know how to make this better. Thanks!



Error when you Add New Scaffold Item for ApplicationUser

Here is one that took me a couple of minutes to figure out: if you are using ASP.NET MVC, and you select Add New Scaffold Item on ApplicationUser, you will get the following error:

Severity Code Description Project File Line Column Suppression State
Error CS0453 The type ‘string’ must be a non-nullable value type in order to use it as parameter ‘T’ in the generic type or method ‘Nullable’ INV..NETCoreApp,Version=v1.0

This is caused by the scaffolding assuming that Id fields are integers, that are nullable, when the ApplicationUser Id is a string (which is not nullable). This is a quick 1-minute fix. Just go and remove all of the question marks after the string, For example:

Details(string? id)


Details(string id)

Super simple.

Until next time…


Hey Microsoft People: Anybody Have an All-Up ASP.NET Core Sample Application?

ASP.NET Core is the newest incarnation of ASP.NET. It allows developers to deploy their applications on any server, not just IIS or Azure, but also Linux. This marks a pretty significant shift for Microsoft, and I absolutely love that Microsoft is branching out.

But, I do have a simple question: has anybody provided comprehensive sample application that shows how all of these Core components work together? There are a ton of great samples on the web for building out sample apps in previous versions of ASP.NET, but there is nothing that I have found that demonstrates an end-to-end yet basic ASP.NET Core application that includes ASP.NET Core MVC and ASP.NET Identity Core.

Let’s get specific: I want to see something like a blog application with multiple authors and a blog administrator, where the users can create and edit/delete their own posts, create and edit/delete their own comments on other people’s posts, and an administrator can create, edit, and delete anything. I actually do not care what the application is, but I do want to see some navigation properties (and whether Lazy Loading works or not, and if it does not work, the right way to get related data loaded), something that leverages Identity Core to manage authentication, authorization, and content (e.g., I want to click on an author’s name, and see all of the posts that they have written).

If you want to get fancy: include minimalist testing (e.g., based on your experience, what are some smart tests to include right off the bat), use Visual Studio 2015, add some additional properties to an Application User (from the ASP.NET Identity Core), create roles and associate users with roles (e.g., admin and author), showcase how to use Scaffolding in an agile manner (e.g., as you change the data model, do you just delete the controller and then add using Scaffolding again…or what is the practice).

It feels like so much code is being developed that the communication of how to leverage the code has become highly siloed and it is difficult to stitch together the right way to do things from a comprehensive perspective. BUT, with a simple sample project (and ideally a quick write-up of how it works) would work wonders to bring more people under the MVC Core umbrella.

If this post already exists, please show me the way. If it does not yet exist, but you could create such a thing, please spend an hour writing out the bullet points or creating a screen recording, and I can convert it into a (temporarily) awesome blog post for you.

Thanks in advance.


Ps-If you do not have this magic blog post that covers ASP.NET Core that includes ASP.NET Core MVC and ASP.NET Identity Core, but you would like to see how all these technologies play together, please drop a comment!

Some useful articles:

Resource-based authorization in ASP.NET MVC:

1 2 3