The document below talks about how we do product at GitLab, not about what. For the what, see Product Direction.


On this page

Who to talk to for what

If you have any product-related questions, comments, input or otherwise, the product manager is the primary person you should talk to, if creating an issue does not suffice. Otherwise, read this section on how to create an issue.

This includes, but is not limited to features, bugs and other changes that need more attention, be prioritized, changed, or discussed.

Product managers will reach out to stakeholders in making or communicating any decision. The weight of balancing priorities and ensuring we build excellent software is on the product manager and they will need all the input they can to achieve this.

See below who to contact for what in detail. In short it is:

Enterprise edition features fall under their respective PM, not under one PM in particular. For instance, Service Desk falls under Victor, because it's part of our Issues.

Find the strict engineering definition of product areas here

Mike Bartlett - Platform and

Reach out for anything that falls under the following things.

For example, if a customer would like us to support a particular extension to LDAP or wants to have a particular importer, contact Mike.

For anything related to, Mike is also the first responder. If you want to know more about the rollout of particular features on or how our plans work, talk to Mike.

Victor Wu - Discussion

For anything that falls under:

This means that if a customer would like to see burndown charts, which relates to issues, you should speak to Victor.

Mark Pundsack - I2P Demo

Anything related to the Idea to Production demo itself is Mark's responsibility, but not all features in the idea-to-production scope.

Joshua Lambert - Prometheus

Anything related to monitoring inside of GitLab, falls under Josh's responsibility. If a customer wants to monitor particular data or see this improved, speak to Joshua.

Fabio Busatto - CI/CD (including Registry, Pages)

Fabio handles anything related to CI and CD within GitLab. If a customer would like to see build artifacts improved, speak to Fabio.

Edge - Job

Edge relates to any of the supporting applications and tools that are not directly part of GitLab. This includes:

This also includes anything related to how GitLab handles licenses and how we handle data that we get from customers through the usage ping.

Build - Joshua

Build is all about how we ship GitLab and make sure everyone can easily install, update and maintain GitLab. This includes:

Sean Packham - Technical Writing

Please contact Sean (Technical Writing Lead) and not the technical writers for any work scheduling.

We, the Technical Writing team, are responsible for the following assets:

We are there to assist developers in their documentation writing process by providing copy editing and reviewing services and are not responsible for writing the first draft of documentation for new or updated features.

We will mantain and improve the overall health of documentation e.g. by creating topic index pages, improving orgnization and creating tutorials.

We manage our documentation tasks for CE and EE on the following issues boards which track labels beginning with docs-:

Job van der Voort - High level and process

Contact Job for any questions about the strategy of product or process within product.

How to work as/with product

At GitLab, the PM leads their specialization. That is, the Platform PM decides what is being worked on by the platform team in which release and makes sure this furthers our goals. This includes bugs, features, architectural changes.

The PM can't be expected to parse every single bug, issue that comes by, so they will have to rely heavily on the input of the various stakeholders. To be able to achieve this, both the PM and the stakeholders have to actively work together. It's a two-way street.

In general terms, if you require something to happen with the product or if you need engineering resources for a particular change, you approach a PM. Preferably through creating an issue, the GitLab way and mentioning them there.

In the same vein, PMs are required to ask for feedback from the stakeholder of particular changes. If a change will affect and its maintenance, a PM should proactively reach out to infrastructure engineers to help with the scoping, design and decisions on this change.

It is then up to the PM to weigh all these inputs and decide on a prioritization. It is to be expected that they are best equipped to make this prioritization, keeping in mind all goals of GitLab.

Example: A customer has a feature request

If you hear a feature request from a customer, you should follow the normal procedure: you create an issue, label it correctly. Let's say the customer requests an enhancement to Issues. You know by reading above that you'll have label this with Discussion and you can mention or reach out to Victor to expedite this if warranted.

Example: Many support requests come in about a bug with CI

Same as before, make sure an issue is made and make your case with Mark on that this is becoming a problem and needs to be fixed. Mark will make sure that this is fixed or resolved in some other way.

Example: I think create new files is slow

Everything in GitLab should be fast and creating files falls under the repository, so you create an issue and make Mike aware of it by mentioning it.

Mike in turn will investigate whether this is a general problem or one specific to, in collaboration with infrastructure and others and schedule any necessary changes for an upcoming release.


Goals of Product

Everyone at GitLab is involved with the product. It's the reason why we are working together.

With every release of GitLab, we want to achieve each of the following goals.

  1. Improve GitLab's existing tools.
  2. Achieve our vision of a complete toolset.
  3. Make our product more interesting for our customers through Products and EE exclusive features.

Scope of responsibilities

The product team is responsible for iteration on most of GitLab's products and projects:

This includes the entire stack and all its facets. The product team needs to prioritize and weigh bugs, features, regressions, performance, but also architectural changes and other changes required for ensuring GitLab is excellent.

Product at GitLab

GitLab is designed and developed in a unique way.

The direction for the GitLab product is spelled out on the Direction page. This document provides lessons and heuristics on how to design changes and new features. Our iterative process is demonstrated in a blog post.

Much of our product philosophies are inspired by Ruby on Rails doctrine of 'Rails is omakase'. I highly suggest reading these.


  1. Minimally Viable Change: Work in iterations by implementing only the minimally viable change.
  2. Convention over Configuration: Avoid configuration and make it work out of the box.
  3. Be Ambitious: do things no one else is doing.
  4. Do not mess with Flow: frictionless from idea to production. Avoid adding clicks.

Product Core Values

The Minimally Viable Change

Reduce every change proposal to its very minimally viable form. This allows us to ship almost anything within a single release, get immediate feedback and avoid deep investments in ideas that might not work. Other advantages:

Despite its minimal form, the change

Convention over Configuration

Prefer choices that are well thought out, based on current best practices. Avoid unnecessary configuration.

For example, when considering adding a checkbox or two radio boxes, think really hard what users really want. Most of the time, you'll find you really only need one solution, so remove the option. When two possible choices really are necessary, the best or most common one should be default, and the other one should be possible. If the non-default choices are significantly less common, then consider taking them out of the main workflow for making decisions such as putting them behind an Advanced configuration tab.

Every configuration in GitLab multiplies its complexity, which means the application is harder to use, harder to develop, and less friendly to its users.

Making features configurable is easy and lazy. It's a natural reaction to propose a big change to be configurable, as you worry it'll negatively affect certain users. However, by making a feature configurable, you've now created two problems.

Work on solutions that work for everyone, that replace all previous solutions.

Sometimes configuration is inevitable or preferable. GitLab should work perfectly right out of the box for most users. Your configuration can't make that experience worse and should always get out of the way of the user.

Encouraging behavior

Convention also implies that we're encouraging our customers to do things in a certain way. A very concrete example of this is the ability to disable pipelines.We believe that our integrated solution will give a superior user experience and we're motivated to encourage behavior. For this reason, adding a configuration to be able to disable this permanently (be that in template or instance-wide), is something that should be avoided.

Encourage favorable behaviors by limiting configuration.

Default to ON

In addition to encouraging behavior by limiting the ability to toggle features, when introducing new features default to turning things ON if they are configurable at all.

Deciding on configurations

Avoiding configurations is not always possible. When we do have to make this choice, the second order of preference is to configure something in the GitLab interface. Only as a last resort should a configuration appear in file (gitlab.rb or gitlab.yml).

Configuration in file

There are two major configuration files available in GitLab. It should be avoided to add new configurations to either.

When you have to add new configuration, make sure that the features and services are on by default. Only add a configuration line to either of this configuration files if the feature or service cannot be fully disabled from the admin UI.

Convention over configuration is also listed in the CONTRIBUTING file in GitLab's repositories.

Be Ambitious

Many crazy, over-ambitious ideas just sound like they are impossible because no one else is doing them.

Because we have amazing engineers and a culture of shipping a minimally viable change, we are able to do a lot more 'impossible' things than other people.

That's why we're shipping merge conflict resolution, why we shipped built-in CI before anyone else did it, why we built a better static pages solution, and why we're able to compete.

Do not mess with Flow

Doing something simple in GitLab should be simple and require no human cpu-cycles to do so. Things that are simple now, should be simple in two and ten years.

This sounds obvious, but messing with Flow is easily done. In most cases, flow is disrupted by adding another action, another click.

For instance: You want users to be made aware of the rules of a project. Your proposal is a little popup that shows the rules before they create an issue. This means that every time that someone creates an issue they need to click once before resuming their normal action. This is unacceptable. A better solution is to add a link to the issue that points the user to this.

It's very hard to maintain flow with a lot of configurations and options. In cases where you want to enforce certain behaviour, the most obvious step is to add another step or action. This can be avoided by making the action work in parallel (like a link in the issue), encouraging rather than enforcing certain behaviours.

We don't want users to be able to construct workflows that break GitLab or make it work in unpredictable ways.


Balancing our great ambition with our dedication to customer success is tough. Add in a growing number of dedicated teams focusing on areas of the product, and it becomes challenging to make sure everything we work on is truly the right thing to work on, right now. To help with that, it's good to keep a few things in mind. To ask a few questions to keep us all aligned.

At a high level, you can think of aligning along these dimensions (not necessarily in priority order):

To make it concrete with an example, the CI/CD team might ask:

Naming features

Naming new features or renaming existing features is notoriously hard and sensitive to many opinions.

Factors in picking a name



The bar for renaming existing features is extremely high, especially for long-time features with a lot of usage. Some valid but not exclusive reasons are:

How to work as a PM

If you follow the guidelines above, you won't be writing long, detailed specs for a part of the product for the next year. So how should you be spending your time?

Invest the majority of your time in understanding the problem deeply (say 70%). Then spend 10% of your time writing the spec for only the first iteration and handling comments, while the remaining 20% you work on promoting it.

A problem you understand well will always have a (seemingly) simple or obvious solution. Reduce it to its simplest form (see above) and only ship that.

Once you've shipped your solution, both you and the community will have a much better idea on what can be improved and what should be prioritized for future iterations.

As a PM you're the person that has to kick-off new initiatives. You're not responsible for shipping something on time, but you are responsible for taking action and setting the direction. Be active everywhere, over-communicate and sell the things you think are important to the rest of the team and community.

As a PM, you need need to set the bar for engineering; to push engineering and the rest of the company. You almost want engineering to complain about the pace that product is setting. Our default instinct will be to slow down. We can't give in to that.

As a PM you don't own the product: ask other people for feedback and give team members and the community the space to suggest and create without your direct intervention. It's your job to make sure something is decided and planned, not to come up with every idea or change.

Dogfood everything

The best way to understand the pain of the users is to go through what we ask them to do while setting up or using GitLab. As a PM, you should go through every feature, at the minimum the ones you are responsible for. All of them. That includes features that are not in GitLab's UI directly but require server configuration. If you, as a PM, can't understand the documentation or struggle to install something, who else would even bother to do it? Going through this is not only beneficial to understand what the pain points are, it will also tell you what you can enhance, from a better flow to a better documentation.

Example: configuring GitLab

Most of GitLab is configured through the file gitlab.rb. It's tempting to add a new parameter in this file - it's easy, fast to do, and won't require to add a new UI to allow the configuration of this new setting. However, changing this file requires you to reconfigure GitLab. To do that, you have to login to your server and type in commands to reconfigure your instance. Possibly, multiple times if you have more than one server.

This is not something that we can ask our customers to do. Only by using your own product and features, will you realize that some practices should be avoided if you can.

New Feature Workflow

Almost everything that we do is documented in an issue.

How to submit a new issue

  1. If you have time, the first thing you should do is search both CE and EE projects if a similar issue already exists. We shouldn't create duplicates if we can avoid them.
  2. Identify if the issue is about GitLab Community Edition (EE) or GitLab Enterprise Edition (EE), although this can easily be changed later.
  3. You should clearly state what the current pain point is, what we are trying to solve, what the benefits will be, what it should do, how to accomplish that and the next steps.
  4. The issue's body should be written in a clear way, without ambiguity.
  5. If the body of the issue contains too many paragraphs, it can surely be rewritten to be shorter.
  6. Do not use acronyms or abbreviations. Everyone should be able to jump on the issue and participate without needing a glossary.
  7. Choose which labels are relevant to the issue. If you are unsure about what certain labels are for, head up to the Labels page (CE or EE) and read the descriptions. The Engineering handbook provides good hints on how to choose the right label.
  8. Unless you know what you are doing, do not
    • assign someone to the issue
    • assign a milestone
    • set a due date
    • add weight - weight represents the technical complexity and should be defined by our developers
  9. Mention the different stakeholders in the body of your issue. In most product related issues, we usually mention the product team members, either the frontend or the backend lead and sometimes the cofounders, as what we do impact the product most of the time. Mentioning the people in the body issue will trigger the notification mechanisms chosen by the people who are mentioned - therefore there is no need to notify people in another channel after the issue has been created (Slack, email).

Performance Issues

Performance is a priority for GitLab. If you want to create a performance issue:

  1. Search for existing issues using the performance label to avoid duplicates.
  2. Use the performance dashboards to validate that the particular area/page you are interested in is indeed suffering from poor performance. If the problem isn't happening on, link the customer issue and try to explain how to reproduce it and/or why we may not be seeing it on our end.
  3. Consider the usage of the GitLab page and the severity of the poor performance in choosing which issues to create.
  4. Create the issue and label it with the performance label. @-mention the related product manager and engineering lead to schedule the issue.


When relevant, you can include a wireframe in your issues in order to illustrate your point. You don't need to include wireframes per se - our UX/design team can help us on that matter. Simply ping them if you need their help. We like Balsamiq for its simplicity and its sketch-y approach. If you don't have inspiration, you can also paste screenshots of similar features in other products.

What is a Meta issue?

Meta is a label assigned to issues that contain a large list of todos. If you are familiar with the Agile methodology, it's similar to an epic. At GitLab we have a short release cycle: the 22nd of every month. In some cases we won't be able to tackle all the tasks of a meta issue in a single release - this is why we centralize all the things that we need to do in a meta issue, then break it down to issues small enough that they will fit into one release. Meta issues generate most of the time lots of comments and passionate discussions. As a consequence, they always lead to something great.

Note: smaller tasks that are part of a meta issue are sometimes also labeled meta. That's because they are part of a meta topic, and thus get the meta label.

Long-lasting issues

A general guideline is that an issue should only span one release. If we know an issue is going to span multiple releases, split it up in multiple issues.

Meta/epic issues are the exception to this rule, but should be kept to a minimum and only serve to guide broader subjects, not a single feature over multiple releases. This to make sure we stick to our values of the minimally viable change.

The above means that feature issues should be closed after a first iteration whenever possible. We'll know more in the future and this keeps remaining issues short and actionable.

In addition, it's almost never a bad idea to throw away an original plan and start fresh. Try to do this more often that you're comfortable. Close the issue and create a new one.

Which issue should you be working on?

When you don't have specific tasks assigned, you should work on issues that are labeled Product work, in both EE and CE projects. These are issues that need our attention the most.

Scheduling timeline throughout a milestone

Issues are scheduled into a milestone (the upcoming release), worked on by engineering and design, and then shipped to production. This timeline is relevant to the release shipped in month M with milestone m issues.

Note that elease timelines are overlapping. For example, when a release is shipped to production on the 22nd, the scope for the following release has already been established earlier in that same month.

An in scope issue already has a docs starter blurb (written by the PM) by the time engineers start development. Engineers should create and merge in the updated docs as part of completing an issue by the 7th. PMs revise the starter docs blurbs in the release post appropriately before the release post is published.

Planning for issues in future releases

We schedule issues month to month. But PMs plan a few releases in advance and have a high-level idea of which issues will likely be scheduled. PMs will label these issues with the coming soon label. This is a signal for all stakeholders that these are candidates, but not guaranteeing scheduling in a particular release, or even at all. The coming soon label will be removed from an issue by a PM when it is scheduled for a release, or if it is no longer a candidate for an upcoming release. In addition, PMs will also label any of these issues with the UX label if they require attention from the UX team. The combination of these two labels in an issue helps the UX team prioritize design work on a given issue, before it is scheduled for a release (wherein the engineering team works on it). Refer to the UX Workflow for further details.

Content of an MVP

We only ship in a Minimally Viable Product mode. Here are some guidelines about it:

Where should you look when you need help?


Internal and external evangelization

Before shipping a new or updated feature, you are responsible for its evangelization, both internally and externally. When something is released, the following teams need to be aware of it as they will all need to do something about it:

You can promote your work in several ways:

GitLab University

To promote a major new feature internally, you can ask to host a GitLab University, a company wide demo session. This is a great opportunity to make sure every one is on the same page.

Major feature rollout

Major features deserve proper attention from product and marketing. With a proper rollout, we'll have ample marketing opportunities and receive more feedback ahead, during and after the release.

Here is the ideal rollout schedule. For each step, there is the indication about who is responsible for it.

  1. Feature is drafted in an issue (PM)
  2. Feature is planned in an upcoming release (PM)
  3. A feature proposal blog post is made (PM or Dev), where we'll describe
    • What we are planning on doing,
    • How you'll be able to buy it: CE or any EE Editions,
    • Link to the issue,
    • When it'll be available, if possible,
    • Anything else that is interesting to share in order to fuel the discussion.
  4. Feature is implemented, documentation is written (Dev).
  5. Feature should appear on the website (Marketing)
    • For very significant features: Feature page on the website is made and pushed, with the mention "Available from X.X"
    • For other features: Feature should be listed on some page (/comparison, Enterprise page, /features page).
  6. Feature is launched with the release (Marketing)
    • "Available from X.X" is removed
    • Documentation and other resources are linked
    • Pricing page is updated if needed
  7. Feature is highlighted in a blog post (Marketing)
    • This post is linked from the feature page on the website (if applicable)

How and when to reject a feature request

Rejecting a feature request or a merge request is not an easy thing. People can feel quite protective of their ideas. They might have invested a lot of time and energy in writing those ideas. You can be tempted to accept a feature only to avoid hurting the people who thought of it. Worst, if you reject an idea too harshly, you might discourage other people to contribute, which is something we want to avoid.

However, as the number of issues and merge requests grow more and more, we should be diligent about rejecting features we are sure will not do. It's better for everyone: for the product team so we don't maintain a huge backlog of things we will not do anyway, and for the users who won't have to wait for our feedback indefinitely.

Note: it's fine to not respond to issues that we think have potential until they gather momentum.

Feature requests and merge requests can be rejected for the following reasons:

Don't forget to thank the authors for the time and effort taken to submit the feature request/merge request. In all cases and without exception, you should be nice and polite when interacting with users and customers.

Responsibilities and Expectations

As a PM you're expected to:

Customer meetings

It's important to get direct feedback from our customers on things we've built, are building or should be building.

As a PM you should have regular meetings with customers that are using the things you've been working on and with customers that are not - in order to get an idea of why they're not switching to our solution.

Set up a meeting

To setup a customer meeting, identify what you're interested in discovering and prepare appropriately.

You can find information about how customers are using GitLab through sales and Sales and support should also be able to bring you into contact with a customer.

There is no formal internal process to schedule a customer meeting, if that need arises, we can formulate one.

During and after

During the meeting, spend most of your time listening and obtaining information. It's not your job to sell GitLab, but it should be obvious when it's the time to tell more about our products.

After the meeting, make sure all your notes and feedback lands in issues.

Enterprise Edition Tiers

There are two EE tiers: Starter and Premium. In the future we'll introduce Ultimate.

EE Starter features are more relevant for organizations that have more than 100 potential users.

EE Premium features are more relevant for organizations that have more than 750 potential users.

EE Ultimate features are more relevant for organizations that have more than 5000 potential users.

Deciding on whether something should be a Premium feature or just a EE-only feature can be tough. In doubt, make it a Premium feature, that's a reversible option, whereas the alternative is not.

Talking about EE only decisions

When talking about why a certain change is limited to Enterprise Edition in public, mention the stewardship paragraph in the about page directly and link to it.

EES and EEP requirements

All EES and EEP features should:

Private tools and dashboards for monitoring and KPI tracking

EE usage: account

Grafana: Google account

Kibana: account

LogTrail: account

Piwik: GitLab 1Password account

S3stat: GitLab 1Password account

Sentry: account

Writing about features

As PM we need to constantly write about the features we ship: in a blog post, internally to promote something, in emails sent to customers.

While we want every PM to have his unique voice and style, there are some guidelines that one should take into account when writing about features. Let's highlight them with a concrete example, Preventing Secrets in your repositories, that we've shipped in 8.12.

It's a bad idea to commit secrets (such as keys and certificates) to your repositories: they'll be cloned to the machines of anyone that has access to the repository, only one of which has to be insecure for the information to be compromised. Yet it happens quite easily. You write git commit -am 'quickfix' && git push and suddenly you've committed files that were meant to stay local!

GitLab now has a new push rule that will prevent commits with secrets from entering the repository.

Just check the checkbox and GitLab will prevent common unsafe files such as .pem and .key from being committed.

Writing release blog posts

For every monthly release, there is a blog post announcing features. The blog post should contain anything exciting or disruptive. We want to help people understand exciting features (which are often new), and increase adoption. Disruptive features may change workflows or even introduce unavoidable inconveniences. We want to anticipate questions and avoid confusion by communicating these changes through the blog post. Smaller tweaks and bug fixes don't necessarily need to be mentioned, but if interesting, can be included at the bottom of the post.