Tuesday, August 4, 2015

Startup founders cheatsheet (Chief product officer)

Define your goals 
The basic definition of "mission" and "vision" of the company is critical when we've past the stage of experimenting with the startup's model and helps you prioritise better. From the Expedia page it looks like this: "Our Mission is to Revolutionise Travel Through the Power of Technology", in this case, it is also helping the company know that leveraging and scaling with "technology" is imperative for the company (along with operations). 

Set 2-3 basic targets for the next 2-3 months (possibly 6 months)
These might be pretty standard and should align with the mission / vision of the company. If your company wants to be the #1 company in Asia for travel, these basic targets might be:
  • Scale to 100,000 app downloads across platforms
  • Increase revenue by 15%
  • Increase daily unique visitors to 3 times the current value  

Image Source: Mind the product

Goals help define epics and create a huge backlog
Now brainstorming how the targets above can be achieved, we create a good backlog of tests we could run that essentially are experiments which help you scale. If I look at point #1, to increase the number of app downloads you could:
  • Market - Inbound / Outbound
  • Share - social / emailing / texting friends of existing users
  • Increase platforms supported (now that you are coming up with iOS and Windows, you are likely to increase the reach)
  • Focus on support 
  • And more.. (the list could go on) 
​With the limited bandwidth, we should prioritise based on a couple of factors:
  • How much is the anticipated impact? - talking in terms of the goal (this would help us reach 6000 more app downloads in the next 1 week based on what other apps have done) 
  • T-Shirt estimates of the epics - focus on achieving something that keeps us running (since we're a startup) is essential, so the cost/benefit factor is essential. 
Create experiments / pre-MVPs
Keeping the creativity scientific is quite essential for any company. If we can potentially put up unscalable hacks to test the market (say 1% of the users) - then we should. In this example, if we can leverage phonegap to basically increase our platform reach as an experiment (maybe for legacy platforms like symbian or blackberry) and that can happen in a few days - then we should, before investing our technology resources toward building a full fledged app for any platform. 

Define MVPs
Pretty standard. - see wikipedia

Other aspects
  • Iterate 
  • Define KPIs and monitor (increase in Downloads, Usage per platform in hours etc.)
  • Validate before things go to production 
  • Define roll out strategy (Geography / Percentage of the users)
  • Test 
  • Plan and discuss with technology and business (scrums / sprint planning / retrospective)
  • Validate what works best for the company (evolve with feedback on what's being done wrong) 

Thursday, October 31, 2013

Friday, April 12, 2013

6 Ways for Product Managers to keep their developers happy and inspired

Read it on yourstory

The concept of “Product Management” in Software Product Company involves a high volume of interaction with the technical teams. When I say that, the first thing that comes to our minds is “Duh! That’s common sense!”, but quite often we don’t do the “interaction” part in the right way.
Product Managers are the CEOs of their own products, they are responsible for the technology, operations, sales, and accounts – basically the success of their products. Hence building the correct product and getting the development effort in the right direction is imperative, and by doing that, we ensure our contribution towards creating a strong and inspiring technical team in the long run. Some key attributes which makes your role as a “Product Manager” a big hit with the technical folks can be -
  • Stay Calm – Be a good listener. Don’t rush your developers into making something without understanding the technical challenges in the current scenario and the long term impact. Over a period of time, it leads to the concept of “Technical Debt” – a phenomenon from which a lot of startups couldn’t come out when they had to scale. There are conclusions to a problem that save up development time drastically and give a more scalable solution for the same feature.
  • Always have a plan- Always keep backup plans & alternatives in case the developer is facing too many issues or surprises. Be the black magician representing the technical team.
  • Make an Impact! – Present your “concept” with confidence. Inspire. Make the upcoming stuff look beautiful to everyone, especially the developers. They should be proud of what they’re making. Be actively involved with the design team to conceptualize your ideas in the best way possible.
  • Be Prepared – Be clear with what you need in your module or product.. Plan iteratively and have healthy timelines. Never hold back a developer in contributing his ideas to make the product better. Try not to leave much scope for unknown items. The developer should clearly know what is needed from the product and what all he is free to improvise on.
  • Have a clear vision – Discarding any amount of work which the developer has done is quite painful for him or her. A developer’s time is gold, for both management and the developers who’ve made the product. Know what’s going on in the team at any point of time. Be sure of what is expected out of them and convey that clearly. Also make sure that the module or deliverable is there to stay by doing a good amount of market research, competition study and proactive discussions with the internal stakeholders including the CXOs, sales & operations teams and probably the board members as well.
  • Create a good environment – Keep your product teams happy and motivated. The workplace and personal relationships within the team should always be healthy and to some extent casual. Incentivise them for working hard and taking initiatives.  Occasional outings, pretty desks, geeky gadgets, good food, public hackathons, Beer Fridays etc.  play an important role in retaining and inspiring developers to spend time at work.
When interacting with the developers, think like them! – understand the problems in their perspective and contribute to alternative suggestions in solving the problems as well. If you’ve been interested in reading this article – get rid of the cliché thinking that Product Managers are not coders, they might not code on production environments but there’s no harm in getting your hands dirty to know what your company does better. Believe it or not, I’ve seen product managers with impressive profiles wasting precious development time on conducting unnecessary meetings, struggling to understand the impact of architectural changes because they are technically unaware. The more you know, the more confidence your technical teams have on you. Quoting Naval Ravikant (from one of his talks) – (Founder of several startups including Angelist, Venturehacks and one of the early investors in Twitter, Foursquare, StackOverflow to name a few) –
Programming in the current generation is the skill of the elite – like reading and writing was in the past

Thursday, April 5, 2012

Image Cropping and Scaling Algorithm using "linear algebra"


I had to formulate an algorithm to convert an image of some resolution - say L x M and
crop / re-size the image into a new resolution say P x R such that I cover the maximum amount 
of points/pixels from the original image.

This can be pretty much applied in a generic way to all programs and websites in need of an optimized algorithm to rescale / reduce the size of the original image in their application such as profile images in social networks etc.


To cover the maximum amount of pixels from the original image we have to focus on cropping the image
to the target aspect ratio first and then re-scaling it to the new resolution. Hence, the problem comes down to achieving the target aspect ratio that would help me capture the maximum amount of pixels of the original image so that I end up with an image which is pretty close to what the original image should have been in the new resolution.


The signature of the function before we started writing the algorithm:

def generate_image_aspect_ratio(path, old_res, new_res=None):

Moving to a new aspect ratio was basic maths, so I formulated the equation which would
give me a new resolution with the same aspect ratio viz:

(old_x - X) / (old_y - Y) = new_x / new_y       ...(i)


old_x * old_y = resolution of the original image
new_x * new_y = target resolution
X = the amount of pixels or points that should be cropped off via the x axis to achieve the target resolution
Y = the amount of pixels or points that should be cropped off via the y axis to achieve the target resolution

old_x / old_y = aspect ratio of the source
new_x / new_y = target aspect ratio

Now we have 2 variables X and Y that we need to minimize so that the highest amount
of pixels are captured from the original image.

The first thing I thought of to minimize these variables was to use differentiation,
but since equation is linear and it did not make sense to put dY/dX = 0 and get the maxima or minima.

One thing I observed here was the values of X of Y should be positive since we
cannot exceed the number of pixels of the original resolution.Hence if we plot a
graph or Y to X, the values we'd minimize would lie in the first quadrant (bulb lights up!):

Rearranging equation (i) to form the equation of a straight line:

Y = (new_y/new_x)X + (old_y - old_x*new_y/new_x)     ...(ii)

analoguous to the equation of the straight line

Y = mX + c      ...(iii)


m = slope of the line = new_y/new_x     ...(iv)
c = Y intercept of the line when X --> 0 = old_y - old_x *new_y/new_x       ...(v)

Notice the slope of the line is always positive as new_y/new_x is always positive.
Hence the line would be at an acute angle to the positive x axis.

The Y intercept i.e. c is therefore the deciding factor on whether X should be zeroed
or Y so that both X and Y are positive.

Thus if:
c >= 0 we get the positive minimum value of Y = c at X = 0
c < 0 we get a positive minimum value of X = -c/m at Y = 0

So, once we have positive mimimum values of X and Y, we can crop the image to
the resolution (old_x - X) * (old_y -Y) which is of the exact/similar aspect ratio
of new_x/new_y.
The next step that follows is re-sizing the image to the resolution new_x * new_y.

This algorithm works for all scenarios viz old_x > new_x or old_x <= new_x or old_y > new_y
or old_y <= new_y. Using this algorithm reduces the number of comparisons to just one variable
that is the Y intercept c and also makes the computations easy.

The code would be published in an EDIT, request for the code via email or in comments.
Θ Ω Sushant ♂

Monday, April 2, 2012

Google Plus now supports REST based url sharing

Google plus has joined facebook and twitter in supporting REST based sharing on profiles, I am still hunting for the documentation of this, but the url "https://plus.google.com/share?url=www.sukh.us"
seems to work for every web address now.

This had been limited to some web addresses like stackoverflow.com, google.com before but now they're pretty much available for use on your website.

Θ Ω Sushant ♂

Friday, March 30, 2012

Stemmers and Lemmatizers in Search Algorithms

Searching / Search Engines are an essential part of every content specific software or web product. The essential part of a good search engine might involve indexing of the content to be searched so that the content can be stored like a hash table to access the content at O(1) complexity.

How do we achieve this indexing? There are two conventional ways to achieve this, which are Forward and Reverse Indexing. While Forward Indexing involves storing the indexes on a sample to token hash table format, Reverse Indexing stores the indexes as token to sample format.

For example if the sentence to be searched is - 'what is love?', the tokens would be 'what', 'is' and 'love'. Now the entry as per forward indexing would store the key as 'what is love?' and the value as a list of tuples 'what', 'is' and 'love', while as per reverse indexing, we would append the keys 'what', 'is' and 'love' withe the sample 'what is love?'.

One major problem to address while indexing is the generation of correct tokens. Finding the root word of each tuple is quite important as it reduces the index size drastically, say equal, equals and equally can be just stored in one root word equal. Here Stemmers and Lemmatizers come into picture.

Stemming strips down a word into a root word using standard english patterns and does it's job pretty efficiently most of the times. It is fast and involves less computation and is widely used in search algorithms.

Lemmatizers are used where a more precise result is required while finding out the root words, where the  number of keys and data size is a constraint and we need more realistic keys. Lemmatizers are a common concept or branch of Natural Language Processing which intelligently find out the root words of the tokens using heuristics and stored language dictionaries. There are various dictionaries being built for various languages which are pretty efficient.

One of the good implementations I experienced which is still at a nacent stage in building it's English dictionary is the Lemmagen. Extremely efficient, pretty good algorithms used and easily portable via platform invokes / c-library. Completely written in native C++ without using any external libraries. I have written a python-usable exposed makefile and other stuff which creates a shared object of this project when complied and exposes its lemmatization functions to the python interpreter. The code for which can be found HERE.

Θ Ω Sushant ♂

Wednesday, March 28, 2012

Yet another NodeJS chat prototype

Technologies used :
Express Framework for Node

Disclaimer : The code / concept here is pretty novice, good for people just starting with nodejs but needs a  lot of refinement.

Installation : You can download nodejs installer according to your OS from nodejs.org or use your OS repositories for a copy of nodejs supported by your OS. The rest of your packages viz socket.io and express are stored in the nodejs repositories and can installed using the following commands:

> npm install socket.io

 > npm install express

MongoDb can be downloaded from the mongodb.org website and you just have to run mongod daemon to ensure the database service is running.

The code for the chat server is available HERE.

Set the mongodb host and port settings on db_ops.js and on the parent folder run:

> node server.js

You would see something like the following image on the server log:

Open up browsers, connect to the server locally via or use you computers IP address and port 8024 and see the chat in action:

Θ Ω Sushant ♂

Startup founders cheatsheet (Chief product officer)

Define your goals  The basic definition of "mission" and "vision" of the company is critical when we've past the...