Humility

The topic of the importance of the customer has been stressed time and time again, but I feel I should offer my own take colored by my personal experiences.

I’ll begin by saying that yes, product management (and by extension, startups) is about ideation, about validation, about execution. But at its root, it is about humility.

Let’s start with a little moral from personal experience. When my friends and I were building our startup back in 2008, we were young, headstrong, and excited to carve our own future and create our own product. We were bursting with ideas about features, about design and interface, and about our core value proposition.  Many times these ideas were based in solid fact. We did our market research. We were exhaustive about competitor analysis. We searched for user feedback about our competitors – what they did well, where they were lacking. But sometimes, our ideas were based on opinion, and this is when you would hear sentences that started like:

“I think that we should build this feature because I feel that…”
“This incentive system would work great because I believe that…”
“We should prioritize this aspect because I think that…”

Months later, we launched our product, entered our pilot phase and struggled with user traction and activity. We had made assumptions on what our users would like as if our singular voices spoke for thousands.

Best lesson ever. In my current job, I build internal analytics tools used by 30+ colleagues – essentially internal products. Even before I begin to build a single feature, I sit down with my users and understand exactly what they need and how they behave. I prototype quickly and put it in front of them to gauge their reactions. I ask them to track the product’s failure modes and alert me when and why they go back to the “old way” of doing things. I don’t make decisions based on assumptions – I prove or disprove assumptions, then make decisions. What this means is that when I launch a product, I know it hits the spot.

Granted, it is easier to create products for a finite, defined userbase than the consumer masses, but the philosophy and approach is the same. It is the same strain of thought that underlies Steve Blank’s customer development framework, the oft-mentioned Minimum Viable Product strategy, and the natural instincts of successful product managers everywhere.

Now with the advent of technology that allows us to code and deploy web applications in months if not weeks, I think it is easy to fall into the trap of saying “I’ll just put my head down, hack this together, and see if it floats. Ten years ago this would have taken X times longer anyways.” Whether you spend 1 year or 2 weeks on a product, it is still a waste of time if you are completely blind to what customers may want. Make the extra effort.

I’ll leave with a great story I heard yesterday night at a Meetup group where a co-founder of Meetup, Matt Meeker, was holding a Q&A session. One of his early startup ventures, through some amazing connections, had been funded by individual investors to the tune of $15mm. Flush with cash, they had hired a literal Who’s Who of financial services executives – group CEO of this bank, CMO of that institution. This incredible collection of minds then proceeded to debate and brainstorm amongst themselves and create what Matt termed “the best Powerpoints you had ever seen”. As the months went by, the conversations continued, these brilliant minds clashed and reassessed, and ultimately the tech requirements given to the contractor changed every week. The timelines extended and eventually the company folded without launching a single product.

Opinions about your product, regardless if they belong to a Regular Joe or to a proven CEO, are still just opinions. You can debate them until you are blue in the face. You can build them with logic, support them with analysis, strengthen them with market research – but they are still opinions, educated guesses at best. Validate your opinions with customers, and then and only then do you have fact. You may be brilliant (or you may think you are), but never ever forget who you serve. And that is the customer.

Learning Links #1

1. Recommendations on how to deploy Django [Hacker News thread]

General consensus:
– virtualenv + pip + requirements files for environment creation
– nginx for serving static files
– gunicorn or Apache/mod_wsgi for web server
– Fabric for automated deployment
– Separate local and base settings files
– Git or Mercurial for DVCS
– South for database migrations

Also learned that there are startups like Djangy that are aiming to be a Platform-as-a-Service for Python/Django applications, much like Heroku for Ruby! Definitely will have to follow this as I imagine it makes deployment and scaling a breeze, especially if sysadmin stuff is not a strong suit.

2. Scaling the world’s largest Django application (Disqus) [DjangoCon 2010]

The content is admittedly over my head, but isn’t it great that the guys at Disqus are willing to let you take a peek under the hood?

3. How to design a good API and why does it matter [Slides at Examville]

Will pack this away to page through later.

Harness the power of Django 3rd party apps

Django is known for the ease of plugging in third-party open-sourced applications into your projects. There is a wealth of Django third-party apps to choose from and several have seen widespread use (and rightfully so!). They fall into three general categories:

• Development tools – these apps allow you to code your application more efficiently
• Internal functionality – these apps help power your product – async task management, screen scraping, thumbnailing, etc.
• External features  – these apps provide pluggable user-facing features – tagging, registration, user notifications, etc.

Could you code your own implementation of what is provided by third-party applications? Of course! Is it efficient to do so? It depends, but if we are talking about development tools or non-core functionality where the general case satisfied by open source alternatives is sufficient, then most likely the answer is no. On the other hand, the more core the functionality is to your product or the more specialized your use case, the higher the likelihood that you will end up rolling your own implementation. Do what makes sense.

Here are a few applications I’d like to point out. You can browse a much more extensive list at Djangoplugables.com.

Third-party apps: Development tools
Regardless of what you are building with Django, these come highly recommended.

1. South
Setting up your database schema in Django is quick and easy. Create your data models in models.py, sync them with your database, and watch Python code get turned into a schema just like that. Maintaining your database schema, however, can be tedious. If you need to drop fields or change the attributes of a field, you not only need to change your data model, but you also have to go into your database and make the parallel changes manually. Having to do things twice? Bummer. Having to do things manually? Double bummer.

Enter South, which makes database maintenance efficient by adding a migration layer. If you change your data model, you can quickly sync the changes with your database in seconds. South compares your latest migration (i.e., snapshot of your schema) with your data model and knows exactly what DDL queries to run to sync the two. Easy breezy.

2. Django-debug-toolbar
Absolutely great for debugging and performance tuning in your development environment. Django-debug-toolbar creates a HTML/Javascript overlay on top of your web application and comes with modules that allow you to deep dive into your environment variables, HTTP headers, SQL queries, and more.

3. Sentry
Sentry is a neat log and error tracking application built by the guys at Disqus, the exciting startup that powers comment systems for the likes of CNN, Techcrunch, Fox News and IGN. It is also the largest deployment of Django in the world. Take a look at their blog post introducing Sentry.

Third-party apps: Internal functionality
Specific use-cases, but powerful.

1. Celery
Celery provides functionality to handle asynchronous tasks and job queuing. There are plenty of use cases:

• Discovery.com uses Celery to asynchronously create variations (high-res, slideshow, thumb, etc.) of images when they are uploaded by editors.
• Yipit uses Celery to queue up and send out thousands of aggregated daily deal e-mails to its subscribers every day. (NYC Django Meetup presentation)
• Here is another use case of Celery for video processing

2. Haystack
Haystack allows you to integrate search functionality into your application. And similar to how the Django ORM can can connect to any number of pluggable back-ends (mySQL, PostgreSQL, SQLite, etc.), Haystack can sit on top of several custom search solutions.

3. easy_thumbnails and sorl-thumbnail
Both are thumbnailing applications that showed up in a survey by Jacob Kaplan-Moss, a co-creator of Django.

Third-party apps: External features
Just listing a few here…

1. Tagging – django-tagging
2. User registration – django-registration
3. Pagination tools – django-pagination
4. User notifications – django-notification

Quora as a learning tool

When first trying to scale a learning curve, the key is having focus in finding the right teachers, the right learning resources, the right case studies. This way you start in the right place and don’t waste time in getting your feet set. This is the case regardless if you are learning for a job, or in my case, for a Django web development hobby.

So far, I have found Quora to be a great resource for seeding my learning path, a heuristic if you will. As a Q&A site, Quora won’t be your textbook or your teacher. However, it is home to many experienced experts, entrepreneurs, founders and tech stars. You may think that they won’t spend the time to answer newbish low-level questions, but they do. Spend a few minutes to type out a well thought-out question and description, and you may get some great advice on where to start. Take a look at a few examples:

I asked: What is the best Django source code available on the Internet for learning purposes?
Who answered: CEO of Instagram, the mobile photo sharing app that reached 1 million users in 3 months.

I asked: What does an ideal Django workflow setup look like?
Who answered: Simon Willison, co-creator of Django.

Not bad, right?

Setting up a Django development environment on Mac OSX

A quick cheat sheet for getting started with Django on a Mac:

1. Install the latest Python release — in my case, this is Python 2.7.
2. Install Xcode from the Mac Dev Center. You’ll need this for the next step…
3. Install virtualenv. Conveniently, this comes with pip, which will be useful for quickly installing other applications.
4. Create your project folder and virtual environment. Activate your virtual environment.

mkdir project_folder
cd project_folder
virtualenv --no-site-packages virtenv
source virtenv/bin/activate


5. Install Django and a few very useful applications: South, django-debug-toolbar, and Yolk. I’ll write a few blog posts on third-party apps later that will go into these in more detail.

virtenv/bin/pip install -E virtenv django
virtenv/bin/pip install -E virtenv south
virtenv/bin/pip install -E virtenv django-debug-toolbar
virtenv/bin/pip install -E virtenv yolk


6. Create your Django project and and your first Django application.

python virtenv/bin/django-admin.py startproject project
cd project
python manage.py startapp app


Funded New York (NYC) Startups

I’ve compiled a list of the better-known funded NYC startups. Here it is!
Source: Quora/Google (for gathering names), Crunchbase (for stats)

How do I learn from scratch?

As an amateur developer, the sheer volume of what you need to learn is daunting. Fortunately, there are a wide range of resources online — the trick is figuring out how to efficiently gather, store, collate and internalize the information — which is a topic for another day. For now, I recommend having a bookmark manager (in-browser or something like Delicious), an RSS reader, Evernote for notes, and Instapaper for efficient source gathering.

So where do you start? I’ll use Django as an example.

Starting off:

1. Official documentation
   The first place to go. In fact, one of the reasons I opted to use Django as my framework was because of the thoroughness and approachability of the official documentation (pdf). It is bar none the best I’ve seen for an open source project of its size.
2. Third-party tutorials / guides / books
   You can often find online third-party tutorials and guides that provide a more manageable learning curve than official documentation — generally, I stumble upon these through Google searches or forum discussions. Examples include: Django Book for Django and Git from the Bottom Up for Git. Of course if you prefer print, Amazon.com has what you need, for a price.
   

Adopting best practices / technology:

With best practices, you won’t find a resource called “All the Best Practices for XYZ”. You’ll have to be proactive and piece it together, with the awareness of the fact that best practices are a) always changing and b) dependent on situation.

1. Conference materials
   If you have the time and money to go to conferences, then knock yourself out. Just be aware that conference talks, especially in the tech/startup space, are uploaded to the web. The presentations will range across the “difficulty-to-comprehend” spectrum, but the great thing about online video is that you can pick and choose. For example, Djangocon’s video archive is up at blip.tv, and I only watch the ones that seem to be of interest and at my expertise level.
   
2. Blogs
   When I come upon a really good blog post when I am researching XYZ, I do two things. I scan the archives and subscribe to the RSS feed. If someone took the time to share insights or write out a detailed how-to on XYZ, it’s likely they have done it for other things as well.
3. Local events – meet-up groups, hackathons, etc.
   I personally am not familiar with these, but they are great places to meet like-minded people and learn from them. If I were to ever go, I would make sure to ask pointed questions (in the right forum / moment). “What are the top 3 things that helped you scale the learning curve when you were just starting off?”, “What had you wished you had known?”, “What are must-haves in terms of A, B and C…?”, “What developments in XYZ excite you?”, etc. Examples: The San Francisco Django Meetup Group and Techcrunch Disrupt Hackathon.
4. Friends and coworkers
   If you know all-star hackers, ask them for advice. Find out what tools, methodologies and skills enable them to work efficiently and effectively. Ask them about their biggest mistakes and lessons learned. You can learn by doing, but you can also get 30% of that from learning by “others doing” if you ask the right questions.

Finding answers to specific questions:

1. Google search
   This is self explanatory. Everyone should be a master of the Google search. Learn how to optimize your keyword searches, how to search within sites, and how to add file types (e.g., .pdf) and hosting sites (e.g., slideshare, rapidshare, blip, vimeo, etc.) to your keywords to zero in on specific types of documents or media.
2. User groups
   User groups are amazing. Use them. The “Django users” Google Group has nearly 20,000 members and tens if not hundreds of new posts a day. Here’s an example of a question I asked and the number and quality of responses. I’d also recommend subscribing to the RSS feed.
   
3. Tech and startup-focused forums / Q&A sites
   Stack Overflow, Hacker News and Quora are some of my favorites destinations for either searching existing questions or posting new ones. These forums are filled with hackers and startup folk who are often willing to share their secret sauce. For example, I asked Quora, “What does an ideal Django workflow look like?” and got a response from a co-founder of Django, which served as a great starting point for my research.

Learning from sample code:

1. Public code repositories
   Besides being a great way to collaborate on open source projects, public code repositories like Github have living, breathing code you can download and look through to your heart’s content. Having the raw code in one hand and the working application in your other is an undeniably great learning resource, especially for those who like to reverse engineer. To point out an example, the entire Python/Django source code for Newsblur is available here. One quick caveat to point out is that oftentimes the code is at an advanced level and there likely won’t be anyone to hand-hold you through the material.
2. Friends and coworkers (again)
   If you have friends or co-workers who have example code you can take a look at (barring confidentiality issues), take advantage of it! If they have time to walk you through and explain why they made the decisions they did, even better. Being outside of the startup/tech industry, I unfortunately don’t have this luxury but wish I did.

Technology for building a web application — choices, choices!

There are a series of important technology decisions to make when building a web application. These decisions are not easily reversible, so it is important to take the time to research your options. I won’t go deeply into pros and cons here, because these are all discussed ad nauseam across the web. However, I will say that it is very important to understand that the right choice is highly dependent on your product and potentially, your team’s existing skillset.

By no means an exhaustive list of questions to consider:

1. Should we be using a Content Management System (CMS) solution like Drupal or should we code the application from scratch? If you are a startup whose core product is your web application, then more likely than not you should maintain the flexibility that comes from choosing the latter. Questions #2 and #3 assume this is the case.
2. What server-side scripting language should we use? PHP? Python? Ruby?
3. Having chosen a scripting language, what framework should we use? For example, PHP has CodeIgniter, Zend, CakePHP. Python has Django, Pylons, TurboGears. Ruby has…well…Rails.
4. What database should we use on the back-end? Relational database mainstays like mySQL or Postgres? NoSQL alternatives like MongoDB or Cassandra? A combination of both?
5. What server setup should we use? An Apache server on a local machine (do you even have the skillset to maintain this…)? A hosted solution like Hostmonster? A more scalable hosted solution like Amazon EC2?
6. What productivity and workflow tools should the team use? Here we can talk about:
   – Development environment – Mac OSX? Windows? A Linux distro?
   – Version control – Git? Subversion? Mercurial? The important thing here is to use something.
   – File sharing (docs/images/designs/etc.) – Dropbox is popular here.
   – Task management / bug tracking
   – Analytics and server monitoring tools

What am I going to use for my little side project? I’ve decided to go with Python/Django with a Postgres back-end. I’ll use my Macbook Pro for development and Git for version control. The other pieces I’ll figure out as I get there.

A business guy building a web app for fun?

Someday, I’d like to be a product guy in the startup world. In the meantime, I’m going to build a web app from scratch and document my observations. I’m not a hacker (at most one step above complete amateur), nor do I envision myself to be one in the future. So why am I doing this?

1. I’d like to be familiar with development best practices — from tools to workflow, from application reusability to scalability. I believe that being able to talk the talk and having walked the walk will make me a more effective product guy. And maybe other aspiring product guys will find reading my posts useful.
2. Hacking, especially in the startup world, is as much about being lean and agile as it is about writing code. The underlying principles are ultimately cross-functional — in fact, lean startup theory probably can be traced back to lean manufacturing and its modern origins in the Toyota assembly line.
3. I can make my contribution towards flattening the web development learning curve. I’ve found newbie-friendly documentation on best practices to be scattered at the best, and pure gobbledygook to the uninitiated at the worst. Hopefully my blog posts can be a useful resource for others who are just getting started.
4. It may be a good opportunity to put customer development theory to practice. I’ve been reading the canonical The Four Steps to Epiphany by Steve Blank and have been itching to give it a go.
5. I like making things. A web app is a thing. Q.E.D.

Wish me luck!