Killing a feature is also important

When it comes to adding a feature to your product, there are countless ways of doing this – and we still mess it up. However, when it comes to killing a feature there isn’t much out there.

As product managers we get excited to take the product to the next level with new features. But deep inside we know there are some features in your product that simply don’t work anymore. You are tracking your product with countless KPIs and metrics to see the health of your product, and its right on the dashboard when a feature isn’t getting clicks or for that matter appreciation (feedback). We either ignore them or simply stop tracking them.

Features that don’t work cost money to support. Worst, just by being present in the product they complicate workflows and risk distracting your users from their core tasks.


You may have heard your customers complain at times: “Your product is to complicated or bulky”. There is a high likely hood that there are features sitting in your product that isn’t being used that’s adding to this bulk and complexity.


Removing a feature isn’t simple. You can’t simply release a new version without a feature. You have to treat removing a feature the same way as adding a new feature to the product:

  • does the existing feature align with your overall product vision & strategy.
  • deprecating a feature needs user search, interviews and analysis.
  • deprecating a feature needs planning, included in the roadmap, and communicate with your users.

To decide if a feature needs to be deprecated:

  • check with your users what are they using to solve their problems instead of your feature.
  • did the feature miss the market?
  • the feature may solve a user problem but its unsustainable for you.
  • the feature solves a problem for a very small set of users, but its not a problem worth solving for you.

When deprecating a feature, communication and transparency is key. Ensure you have two set paths, i.e. End of Life (EoL) and End of Support (EoS) and there is sufficient time for the users (if any) to move to other options if they are using this feature.

To ensure a successful EoL and EoS,

  • remove the feature so that new users do not have access to this
  • de-emphasize the feature in the UI – out of sight out of mind.
  • suggest alternatives and help your users migrate

Lastly, make sure this is part of your continuous onboarding strategy, where you are communicating this to your users and helping them migrate through the EoL and EoS timeframe.

Learning golang – my journey

As a product manager by trade, I don’t need sit and learn programming languages as I’m not expected to site down and write code. But the engineering in me wants to keep building.

Looking at data is a big part of my day-to-day work. You might have a data analyst to help you with this, but the analysis of the data and understanding you get of your customer is not something you can delegate. Thus, most cases I take matter into my hands.

Now there is only so much SQL queries you can write and run daily. At some point in time you want to store these values and trend over time. Chances are you have system that will do the job for you, but when you don’t you take matters at hand.

Python was a go to choice, but I wanted to build a cli tool that would allow me to run cURL like commands to an API and capture some of the timing metrics as well. At times I would have 100’s of URL’s that I did like to check.

I also wanted to pull RUM data from our vendor tool for pages of my SaaS application and correlate that data that I pulled from the database.

I had Grafana and MySQL set up to view this data, but I needed something that would run my queries, cURL my API endpoints and pull data from 3rd party application into this MySQL database.

After talking to a few friends, I looked into golang as a means to do whatever automation I needed to do at my end. One of the biggest reason to consider golang was the concurrency – easy to understand and implement.

I have a full fledged system set up today that allows me to look into trends in my SaaS applications with multiple data sources contributing to these dashboards. Here are a few links I used to get myself started into golang.

First, head to golang.org and install the framework from the download page.

Go by Examplehttps://gobyexample.com
Literally from basics. I read this just to get a hang on their syntax and how to structure code.

The Go+ language for engineering, STEM education, and data sciencehttps://github.com/goplus/gop
Yet another library that cuts down the learning by focusing on the most basics of things. Really good library.

How to write go codehttps://golang.org/doc/code
When you first start writing go code and everything is in a single file; it woks like magic. When you start separating your layers, is when you get into trouble. This tutorial form Google was one of the best to get me started and understanding how to structure my code.

SOLID Go Design by Dave Cheney – https://dave.cheney.net/2016/08/20/solid-go-design
Once you get a hang of things, follow Dave Cheney’s blog. This will get you started in golang design patters and most important concurrency.

How to create a CLI in golang with cobrahttps://towardsdatascience.com/how-to-create-a-cli-in-golang-with-cobra-d729641c7177
I wanted to build a CLI tool and there is no better library then cobra and viper. I have no moved away from these libraries and build everything thats available in golang; but these libraries will get you started quickly and also help you understand how to build cli tolls and read settings from a config file.

Viper for config file settings – https://github.com/spf13/viper
Cobra for building a CLI tool – https://github.com/spf13/cobra

Lastly an example of golang CRUD using MySQL form scratchhttps://www.golangprograms.com/example-of-golang-crud-using-mysql-from-scratch.html
This will give you a basic understanding on pushing data into a database.

It is always good to refer to codebases as well to get an understanding of how to structure your code or to simply see deeding patters. Some code bases I looked into were Kubernetes and Elastic’s Beats.

Applying a ‘Time-To-Market’ KPI in product

Gabriel Dan on Mind the Product:

It’s a KPI—used mostly by the business—to measure the time required to move a product or service from conception to market (until it is available to be purchased). The process is the combined efforts of all stakeholders, product management, marketing, and so on. It includes workflow steps and strategies involved throughout the process. It’s usually calculated in days/weeks/months/years but it can be met in other forms too depending on how the different organizations will want to implement this.

This is simply amazing and important especially when you are constantly trying to beat your competition to get out in the market to capture your audience.

The shorter the time to market is, the quicker the return on investment (ROI) can be realized, therefore you can imagine why it’s important for businesses.

The quicker the product gets on the market, the bigger market share the company will get especially in an unaddressed segment facing less competition and thus enjoys better profit margins. Getting fresh and relevant products to market quickly attracts customers.

Exactly. It is very common to get into the phase of doing more before releasing to the market. The TTM metric forces you to be frugal about your MVP.

Gabriel Dan does a great job setting the premise and goes on the explain how the TTM should be calculated. Highly recommended.

User Experience (UX) Metrics for Product Managers

As Product Managers we are obsessed with what we build. Well, we all want to build the best darn product ever. We immerse ourselves in understanding

  1. how our users are finding the product or if the campaigns are working (Reach, Activation),
  2. How many users and if they are engaging well with the product (Active Users, Engagement), and
  3. Last but not least, if your users come back (Retention).
    The priority of these metrics changes depending on the nature of your app.

Give your product managers complete autonomy / authority to drive campaigns, onboard users. They are the best and most aware of the product they are building.

Automation is on the rise. With CI/CD and other similar processes; we are able to ship code at a faster rate then ever before. Delivering value to customers at this rate is great; but, it is important you focus on quality over quantity.

When we talk about quality, Performance is right up top. It is a common practice to check for performance before your application goes live. Most organizations do this.
Google’s Lighthouse is widely used for this purpose for web based consumer application. Google’s Lighthouse-CI is integrates with your CI/CD tool which passes or fails a builds based on performance rules.

Note: You can ignore the SEO numbers/suggestions for your SaaS application.

These tools ensure quality. This helps with SEO, accessibility and best practices and measures performance metrics. Performance metrics are important to understand how your page loads as this impacts user experience.

Important Metrics to track User Experience

Start Render or First Paint & Largest Contentful Paint (LCP)

The reason I have suggested an option to choose from 2 metrics is because one of them is easier to capture then the other. You can be the best judge when it comes to accuracy of the metric and if this is something that will work for you.

Start Render is measured by capturing a video of the page load and looking at each frame for the first time the browser displays something other than a blank page. This is typically measured in lab or using a synthetic monitoring tool like Catchpoint and is the most accurate measurement for it.

First Paint (FP) is a measurement reported by the browser itself; that is, when it thinks it painted the first content. It is fairly accurate but sometimes it reports the time when the browser painted nothing but a blank screen.

Largest Contentful Paint (LCP) is yet another metric by Google as they continue to foray into web performance metrics and is part of their Web Vitals offering.

FP should typically happen under 2 seconds. Imagine the application you are trying to use sows up a blank screen for a few seconds before it starts rendering the content. This is NOT a good user experience. Show a blank screen for more than 2 seconds after entering the URL can cause page abandonment. You want to tell the user as soon as possible that some activity is happening. This could be as simple as chaining the background color which alerts the user that the application is loading.

According to LCP‘s definition; it is the time it takes for the largest above the fold content to load. For example, breaking story on a news website. This is an important metric, because users typically expect to see something relevant quickly.

Together with FP (or start render) and LCP measures the Loading Experience for a user.

Time To Interactive (TTI)

According to web.vitals:

TTI metric measures the time from when the page starts loading to when its main sub-resources have loaded and it is capable of reliably responding to user input quickly.

TTI follows FP. Having a big gap between these two would mean your users are waiting until the entire page completes rendering. This means if you have an extremely fast loading web application but a horrible TTI; the performance is worst compared to a slower application.

We tend to build muscle memory often for things that we use constantly. This is true for SaaS applications. Most of the tools that I use at work; I have built in muscle memory, which makes me position my mouse on the browser at a location the link/button will render and the moment it does; I tend to click it.

Speed Index

Speed Index is one of the metrics that is tracked by Google’s Lighthouse (or Web.Vitals) as part of performance report:

Speed Index measures how quickly content is visually displayed during page load. Lighthouse first captures a video of the page loading in the browser and computes the visual progression between frames. Lighthouse then uses the Speedline Node.js module to generate the Speed Index score.

In simple words, Speed Index metric tells you at what rate does the visible content (above the page fold) is loading. The lower the score, the better is the user experience.

Typically all of these metrics should be tracked by your engineering or performance teams; however, it is good practice to keep an eye on these as they would be benchmarked based on historical data or competitive data. Breaching the benchmark or any changes in these benchmark can have a direct impact on the user experience of your application.

If you are curing to now more, here is a great article on Understanding Speed Index | Performance Metrics.


How to track metrics?

You can use a Synthetic Monitoring tool like Catchpoint. If you are the adventurous kind you can use Google Puppeteer to run a lighthouse test to capture the above metrics and Grafana to show a historical time series of these performance metrics.

As a product manger I track a lot more metrics and have built my entire dashboard on Grafana (more on this in a later post). I have a set up using Google Puppeteer and Lighthouse libraries that I use to push these metrics and other performance metrics provided by Google Lighthouse in my Dashboard every 24 hours. This allows me to see my performance numbers along with other KPI’s.