The Product Intelligence Group is part of the Growth section. Our group focuses on providing GitLab's team with data-driven product insights to build a better GitLab. To do this, we build data collection and analytics tools within the GitLab product in a privacy-focused manner. Insights generated from Product Intelligence enables us to identify the best places to invest people and resources, what product categories mature faster, where our user experience can be improved, and how product changes impact the business. You can learn more about what we're building next on the Product Intelligence Direction page.
How we work:
The following people are permanent members of the Product Intelligence Group:
Our team uses a hybrid of Kanban for our project management process. This process balances the continuous flow of Kanban with GitLab's monthly milestone release cycle.
Our team use the following workflow stages defined in the Product Development Flow:
||Applied by the Product Manager for incoming issues that have not been refined or prioritized.|
||Applied by the Product Manager for issues where the PM is developing a thorough understanding of the problem|
||Applied by the Product Manager or Designer (or Product Intelligence Engineer) to ideate and propose solutions. The proposed solutions should be reviewed by engineering to ensure technical feasibility.|
||Applied by the Product Manager or Designer (or Product Intelligence Engineer) to validate a proposed solution through user interviews or usability testing.|
||Applied by the Product Manager on or before the 4th of the month signaling an intent to prioritize the issue for the next milestone.|
||Applied by Product Manager. Issue has been broken down and prioritized by PM for development. Issue also has a milestone assigned at this point.|
||Applied by the engineer after work (including documentation) has begun on the issue. An MR is typically linked to the issue at this point.|
||Applied by an engineer indicating that all MRs required to close an issue are in review.|
||Applied by engineer after the MRs in the issue have been merged, this label is applied signaling the issue needs to be verified in staging or production.|
||Applied by any team member if at any time during development the issue is blocked. For example: technical issue, open question to PM or PD, cross-group dependency.|
We use an epic roadmap to track epic progress on a quarterly basis. The epic roadmap is a live view of the Product Intelligence Direction page.
To keep things simple, we primarily use the gitlab.com/gitlab-org group for our roadmap. If epics are created on the gitlab.com/gitlab-com and gitlab.com/gitlab-services groups, we create placeholders of them on gitlab.com/gitlab-org so that all epics show up in a single roadmap view.
|gitlab-org Epic Roadmap||-||-|
We use issue boards to track issue progress on a daily basis. Issue boards are our single source of truth for the status of our work. Issue boards should be viewed at the highest group level for visibility into all nested projects in a group.
There are three groups we use:
|gitlab-org Issue Board||gitlab-com Issue Board||gitlab-services Issue Board||-|
The work done by our team mainly fall into two categories: product initiatives and engineering initiatives.
Product initiatives: This work is primarily related to driving value for our customers. This work is defined by a product manager and is outlined in the team's product roadmap.
Engineering initiatives: This work is primarily related to driving value for internal teams. This work is defined by an engineer and can include bug fixes, follow-up issues, refactoring, career development work, or anything an engineer thinks is important enough to be worked on.
We prioritize our product roadmap using milestone priority labels:
Prioritization of our product roadmap is determined by our product managers. Every epic and issue that is part of a product roadmap should have a priority label.
We work from the highest to the lowest priority when working on product initiatives. For design prioritization, see priority for UX issues.
We follow the iteration process outlined by the Engineering function.
We follow the estimation process outlined by the Growth sub-department.
To properly set expectations for product managers and other stakeholders, our team may decide to add a due date onto an issue. Due dates are not meant to pressure our team but are instead used to communicate an expected delivery date.
We may also use due dates as a way to timebox our iterations. Instead of spending a month on shipping a feature, we may set a due date of a week to force ourselves to come up with a smaller iteration.
Refinement is the responsibility of every team member. Every Friday, Slack will post a refinement reminder in our group channel. During refinement, we make sure that every issue on the issue board is kept up to date with the necessary details and next steps.
Our team pays close attention to the Product Development Timeline as our group is dependent on the GitLab self-managed release cycle. Since our group uses a hybrid kanban process, we only pay attention to certain dates such as:
In addition to these dates, our team also does the following:
To help our team be efficient, we explicitly define how our team uses epics and issues.
We aim to create issues in the same project as where the future merge request will live. And we aim to create epics at the topmost-level group that makes the most sense for its collection of child epics and issues. For example, if an experiment is being run in the CustomersDot, the epic should be created in the
gitlab-org group, and the issue should be created in the
We emphasize creating the epic at the topmost-level group so that it will show up on our epic roadmap. And we emphasize creating the issue in the right project to avoid having to close and move it later in the development process. If the location of the future merge request cannot be determined, we will create the issue in our catch-all growth team-tasks project.
We used to aim for a 1:1 ratio between issues and merge requests, mainly for the sake of status visibility at the issue board level. We have since moved to using epics and the epic roadmap for product management visibility, and we are comfortable with the amount of status updates received during our weekly sync meetings as well as through comments within issues themselves.
If an issue requires multiple merge requests, we no longer recommend splitting the issue itself up in order to maintain a 1:1 ratio of issues to MRs. The advantage is that an engineer is able to create an arbitrary number of MRs for a single issue and can move much more quickly through them. The trade-off is that doing so makes it more difficult to communicate the overall status of the issue itself. It is the engineer's responsibility to make sure that the status of each issue they are working on is effectively communicated to their Product Manager.
We group related issues together using parent epics and child epics, providing us with a better visual overview of our roadmap.
[Product]to indicate their area of focus. The prefixes can be combined if the epic holds issues of different areas, e.g.
UXto easily filter epics.
After a design is done, the design issue needs to be set to
workflow::planning breakdown and engineering takes over the process of breaking it down. The design issue can be closed after break down is done.
Epics can contain issues and/or child epics. A child epic could for example be the first iteration of the parent epic. An example of how the structure of an epic could look:
Epics have the following limitations:
gitlab-orgfrom an epic created in
gitlab-orgcan't link to an issue created in
To overcome this, we will:
The parent epic should live on the top-level group where most of the issues and child epics will be created.
We use issue labels to keep us organized. Every issue has a set of required labels that the issue must be tagged with. Every issue also has a set of optional labels that are used as needed.
~"workflow::ready for development,
~"workflow::In dev, etc.
MR labels can mirror issue labels (which is automatically done when created from an issue), but only certain labels are required for correctly measuring throughput.
We tag each issue and MR with the planned milestone or the milestone at time of completion.
Our group holds synchronus meetings to gain additional clarity and alignment on our async discussions. We aim to record all of our meetings as our team members are spread across several timezones and often cannot attend at the scheduled time.
We have daily asynchronous standups. Team members are using either status hero or geekbot for their daily standups. The purpose of these standups are to allow team members to have visibility into what everyone else is doing, allow a platform for asking for and offering help, and provide a starting point for some social conversations.
Three questions are asked at each standup:
One of our main engineering metrics is throughput which is the total number of MRs that are completed and in production in a given period of time. We use throughput to encourage small MRs and to practice our values of iteration, although we do not necessarily equate one MR to one complete iteration. We recognize that just as an issue may be broken down into multiple merge requests, so can iteration of a feature be spread across several MRs, especially with the use of feature flags. Read more about why we adopted this throughput model.
All new team members to the Product Intelligence teams are provided two onboarding issues to help ramp up on our analytics tooling. New team member members should create their own onboarding issues in the gitlab-org/growth/team-tasks project. Note that this template lives in our handbook page instead of inside a GitLab template as it provides better visibility for incoming team members.
## Overview The goal of this issue is to introduce you to how usage ping works. Your first task is to locally replicate the sending and receiving of a Usage Ping. In order to do this, you will traverse the gitlab and versions codebases to see how a usage ping is sent and collected. Please work with your onboarding buddy if you have any questions. ## Steps - [ ] Read the [Product Intelligence Guide](https://about.gitlab.com/handbook/product/product-intelligence-guide/) - [ ] Read the [Usage Ping Guide](https://docs.gitlab.com/ee/development/usage_ping/) - [ ] Clone and start https://gitlab.com/gitlab-org/gitlab - [ ] Clone and start https://gitlab.com/gitlab-services/version-gitlab-com - [ ] Setup versions to listen for incoming usage pings - [ ] Point gitlab to the versions endpoint instead of the default endpoint - [ ] In gitlab via rails console, manually trigger a usage ping - [ ] In versions via rails console, check that a usage ping was successfully received, parsed, and stored in the Versions database. - [ ] Notify your manager and onboarding buddy once this issue is complete - [ ] Ask your manager to add you to the [/gitlab-org/growth/product-intelligence/engineers/](https://gitlab.com/groups/gitlab-org/growth/product-intelligence/engineers/-/group_members) so that you can start doing [Product Intelligence reviews](https://docs.gitlab.com/ee/development/usage_ping/#9-ask-for-a-product-intelligence-review) - [ ] Close off this issue
## Overview The goal of this issue is to introduce you to how Snowplow works. Your first task is to locally replicate the sending and receiving of Snowplow events. In order to do this, you will traverse the gitlab and snowplow codebases to see how a snowplow event is sent and collected. Please work with your onboarding buddy if you have any questions. ## Steps - [ ] Read the [Product Intelligence Guide](https://about.gitlab.com/handbook/product/product-intelligence-guide/) - [ ] Read the [Snowplow Guide](https://docs.gitlab.com/ee/development/snowplow/index.html) - [ ] Clone and start GitLab https://gitlab.com/gitlab-org/gitlab - [ ] Clone and read through the readme for Snowplow Iglu https://gitlab.com/gitlab-org/iglu - [ ] Clone and start Snowplow Micro https://docs.gitlab.com/ee/development/snowplow/index.html#snowplow-micro - [ ] Add a Snowplow event using HAML https://docs.gitlab.com/ee/development/snowplow/index.html#tracking-in-haml-or-vue-templates - [ ] Add a Snowplow event using Ruby https://docs.gitlab.com/ee/development/snowplow/index.html#implementing-snowplow-ruby-backend-tracking - [ ] Using your browser, navigate to wherever the event was added and trigger all the added Snowplow events (HAML, Ruby) - [ ] In Snowplow Micro, ensure all of the above mentioned events are successfully captured as good events in `localhost:9090/micro/good` - [ ] Notify your manager and onboarding buddy once this issue is complete - [ ] Ask your manager to add you to the [/gitlab-org/growth/product-intelligence/engineers/](https://gitlab.com/groups/gitlab-org/growth/product-intelligence/engineers/-/group_members) so that you can start doing [Product Intelligence reviews](https://docs.gitlab.com/ee/development/usage_ping/#9-ask-for-a-product-intelligence-review) - [ ] Close off this issue
|Product Intelligence Guide||A guide to Product Intelligence|
|Usage Ping Guide||An implementation guide for Usage Ping|
|Snowplow Guide||An implementation guide for Snowplow|
|Event Dictionary||A SSoT for all collected metrics and events|
|Implementing Product Performance Indicators||The workflow for putting product performance indicators in place|
|Product Intelligence Direction||The roadmap for Product Intelligence at GitLab|
|Product Intelligence Development Process||The development process for the Product Intelligence groups|
|Growth Product Direction||The roadmap for Growth at GitLab|
|Growth Product Handbook||The product process for the Growth sub-department|
|Growth Sub-Department Development Process.||The development process for the Growth sub-department|
|Growth Sub-Department Performance Indicators Process||The performance indicators for the Growth sub-department|
|Growth UX Process||The UX process for the Growth sub-department|
|Growth QE Process||The QE process for the Growth sub-department|
|GitLab Performance Snowplow Dashboards||Performance dashbaords for GitLab.com via Snowplow|