https://docs.gitlab.com/ee/user/free_user_limit.html

GitLab documentation home Docs

  * 

  * What's new?

  * Get free trial

Home
Tutorials
Find your way around GitLab
Tutorial: Use the left sidebar to navigate GitLab
Learn Git
Plan and track your work
Build your application
Secure your application
Manage your infrastructure
Develop with GitLab
Find more tutorials
Subscribe
Choose a subscription
Compare self-managed to SaaS
GitLab SaaS
Free user limit
Read-only namespaces
GitLab self-managed
Activate Enterprise Edition
GitLab Dedicated
Community programs
Customers Portal
Quarterly reconciliation
Storage usage quota
Compute quota
Features available to Starter and Bronze subscribers
Install
Requirements
PostgreSQL extensions
Installation methods
Linux package (Omnibus)
Architecture
Omnibus packages and images
Package information
Package defaults
Package licensing
Package signatures
PostgreSQL versions
Installation
Deprecation policy
Supported OSes
Manual installation
Install JiHu Edition
Configure
Action Cable
Backups
Configuration options
Custom environment variables
Database
GitLab Mattermost
Grafana
High availability roles
Logs
Microsoft Graph Mailer
NGINX
Gitaly Cluster
Prometheus
Puma
Raspberry Pi
Redis
SMTP
Rake tasks
SSL
Troubleshooting SSL
DNS
Image scaling
Memory-constrained environments
Release process
Maintain
Troubleshooting
Helm chart (Kubernetes)
Install
Test the GitLab chart on GKE or EKS
Install prerequisites
Chart versions
Secrets
RBAC
Storage
TLS
Set up cloud resources
Azure Kubernetes Service
Amazon EKS
Google Kubernetes Engine
OpenShift Origin
Oracle Container Engine for Kubernetes
Deploy the Helm chart
Deployment options
Configure
Globals
GitLab subcharts
Gitaly chart
GitLab Exporter chart
GitLab Pages chart
GitLab Runner chart
GitLab Shell chart
KAS chart
Mailroom chart
Migrations chart
Praefect chart
Sidekiq chart
Spamcheck chart
Toolbox chart
Webservice chart
Minio chart
Nginx chart
Registry chart
Zoekt chart
Advanced
Custom Docker images
External database
External Gitaly
External GitLab Pages
External Mattermost
External Nginx
External object storage
External Redis
FIPS-compliant images
Geo
Internal TLS between services
Multiple databases
Persistent volumes
Red Hat UBI-based images
Upgrade
Database upgrade
Release notes 7.0
Release notes 6.0
Release notes 5.0
Release notes 4.0
Release notes 3.0
Release notes 2.0
Release notes 1.0
Upgrade old versions
Backup and Restore
Backup
Restore
Migration guides
Migrate from the Linux package
Migrate to the Linux package
Migrate between Helm versions
Migrate to MinIO
Uninstall
Troubleshooting
Operator (Kubernetes)
Install
Backup and restore
Upgrade GitLab
Support for Git over SSH
Upgrade the Operator
Ingress in OpenShift
RedHat-certified images
Security context constraints
Troubleshooting
Docker
Self-compiled (source)
Install under a relative URL
Cloud providers
Azure
Google Cloud Platform (GCP)
Amazon Web Services (AWS)
EKS best practices
GitLab SRE for AWS
GitLab Cloud Native Hybrid on AWS EKS
Manual install on AWS
Offline GitLab
Offline GitLab installation
Reference Architectures
Up to 1,000 users
Up to 2,000 users
Up to 3,000 users
Up to 5,000 users
Up to 10,000 users
Up to 25,000 users
Up to 50,000 users
Steps after installing
Upgrade GitLab
Plan an upgrade
Background migrations
Upgrade Omnibus instance
Convert to Omnibus
Convert to Enterprise Edition
Package signatures
GitLab 16 changes
GitLab 15 changes
GitLab 14 changes
GitLab 13 changes
GitLab 12 changes
GitLab 11 changes
GitLab 10 changes
Downgrade
Upgrade source instance
Patch versions
Change from Community Edition to Enterprise Edition
Zero-downtime upgrades for multi-node instances
Upgrades with downtime for multi-node instances
Change from Enterprise Edition to Community Edition
Releases and maintenance
Deprecations by version
Terminology
Removals by version
What's new
Install GitLab Runner
Linux
Linux manual install
FreeBSD
macOS
Windows
Docker
Helm chart
GitLab agent
Operator
Bleeding edge releases
Configure GitLab Runner
Advanced configuration
Autoscale configuration
Docker Machine Executor autoscale
Autoscale on AWS EC2
Autoscale on AWS Fargate
Commands
Feature flags
macOS setup
Runner Operator on OpenShift
Running behind a proxy
Rate limited requests
Graphical processing units
Self-signed certificates
System services
Speed up job execution
Troubleshooting
Administer
Get started
All feature flags
Enable features behind feature flags
Configure your installation
Authentication and authorization
AliCloud
Atlassian
Atlassian Crowd (deprecated)
Auth0
AWS Cognito
Azure
Bitbucket Cloud
DingTalk
Facebook
Generic OAuth2
GitHub
GitLab.com
Google
JWT
Kerberos
LDAP
LDAP synchronization
LDAP (Google Secure)
Rake tasks
Troubleshooting
OAuth service provider
OmniAuth
OpenID Connect identity
OpenID Connect OmniAuth
Salesforce
SAML
Configure SCIM
Shibboleth
Smartcard
Test OIDC/OAuth in GitLab
Twitter
Vault
CI/CD
Configuration and Admin Area
Admin Area settings
Account and limit settings
Appearance
Authentication
CI/CD
Application cache interval
Custom instance-level project templates
Deprecated API rate limits
Diff limits
Email
External authorization
External pipeline validation
Federated Learning of Cohorts (FLoC)
Geo sites
Git abuse rate limit
Git LFS administration
GitLab Pages
GitLab Pages for source installations
Troubleshooting
Health Check
Incident management rate limits
Instance template repository
Job artifacts
Job logs
Labels
Log system
Parse logs with jq
Trace logs based on correlation ID
Maintenance Mode
Merge request approvals
Package Registry rate limits
Polling interval multiplier
Protected paths
Push event activities limit
Rate limits on Repository files API
Rate limits on Git LFS
Rate limits on issue creation
Rate limits on raw endpoints
Rate limits on note creation
Rate limits on Users API
Rate limits on Projects API
Rate limits on pipeline creation
Reply by email
Repository checks
Security and Compliance
Sign-in and help page text
Sign-in restrictions
Sign-up restrictions
Spamcheck
System Hooks
Terms of service and privacy policy
Third-party offers
Timezone
Uploads
Uploads migration Rake tasks
Uploads sanitization Rake tasks
User Cohorts
User and IP rate limits
Visibility and access controls
Consul
Environment variables
File hooks
Git protocol v2
Incoming email
Rake tasks
Instance limits
Instance Review
PostgreSQL
Replication and failover
Standalone packaged database
PgBouncer
Database Load Balancing
External database service
Move instances
Multiple databases
Load balancer
NFS
Postfix
Redis
Configure the bundled Redis for replication
Configure your own Redis for replication
Standalone Redis configuration
Troubleshooting
Sidekiq
Multiple Sidekiq processes
Processing specific job classes
Sidekiq MemoryKiller
Sidekiq health check
Sidekiq job migration
Sidekiq job size limits
Troubleshooting
S/MIME signing
Repository storage
Repository storage types
Gitaly and Geo capabilities
Gitaly and Gitaly Cluster
Configure Gitaly
Configure Gitaly Cluster
Monitoring
Recovery options
Troubleshooting
Gitaly reference
Praefect Rake tasks
Gitaly timeouts
Repository storage Rake tasks
List repositories Rake task
Migrate snippets Rake tasks
Object storage
Merge request diffs storage
Static objects external storage
Geo
Setting up Geo
Database replication
External PostgreSQL instances
Configuration
Using a Geo site
Configure secondary proxying
Location-aware public URL
Upgrading Geo sites
Version-specific upgrades
Using object storage
Container registry for a secondary site
Geo for multiple servers
Geo security review
Location-aware Git remote URLs
Single Sign On (SSO)
Tuning Geo
Rake tasks
Disable Geo
Removing a Geo site
Supported data types
Frequently asked questions
Troubleshooting
Validation tests
Geo Glossary
Disaster recovery (Geo)
Planned failover
Bring primary back
Automatic background verification
Agent server for Kubernetes
Server hooks
Terraform state
Terraform limits
Packages
Container Registry
Dependency Proxy
Web terminals
Wikis
Invalidate Markdown cache
Issue closing pattern
Snippets
Host the product documentation
Configure GitLab Dedicated
Maintain your installation
Housekeeping
Clean up with Rake tasks
Maintenance Rake tasks
Integrity check Rake task
Activate GitLab EE with license
Fast SSH key lookup
Filesystem benchmarking
gitlab-sshd
Rails console
Use SSH certificates
Enable encrypted configuration
Rake tasks
Backup and restore
Back up GitLab
Restore GitLab
Inactive project deletion
Move repositories
Read-only state
Restart GitLab
Troubleshooting
Secure your installation
Limits on SSH keys
Rate limits
Filtering outbound requests
Information exclusivity
Manage the CRIME vulnerability
Enforce two-factor authentication (2FA)
Identity verification
Account email verification
Make new users confirm email
Runners
Proxying assets
CI/CD variables
Token overview
Compliance features
Respond to security incidents
Hardening
General concepts
Application recommendations
CI/CD recommendations
Configuration recommendations
Operating system recommendations
Administer users
Reset user password
Unlock a user
Review abuse reports
User file uploads
Password storage
Credentials inventory
Custom password length limits
Generated passwords and integrated authentication
Global user settings
Moderate users
Auditor users
External users
Configure the libravatar service
Broadcast messages
Email from GitLab
Rake tasks
Use GitLab
Set up your organization
Tutorial: Set up your organization
Namespaces
Members
Groups
Manage groups
Group access and permissions
Moderate users
Custom group-level project templates
Group access tokens
Migrate groups
SAML Group Sync
Compliance frameworks
Tutorial: Create a compliance pipeline
Troubleshooting SAML
SAML SSO for GitLab.com groups
Configure SCIM
Example group SAML and SCIM configurations
Troubleshooting SCIM
Subgroups
Tutorial: Move a personal project to a group
Tutorial: Convert a personal namespace into a group
Git abuse rate limit
Troubleshooting groups
Enterprise users
User account options
Active sessions
Comment templates
Contributions calendar
Achievements
Permissions and roles
Personal access tokens
Profile preferences
Notification emails
User passwords
Two-factor authentication
Report abuse
Delete account
SSH keys
GitLab.com settings
Organize work with projects
Create a project
Manage projects
Project visibility
Project settings
Project access tokens
Share projects
Reserved project and group names
Search
Advanced search
Exact code search
Badges
Code intelligence
Compliance
License scanning of CycloneDX files
License approval policies
License list
SPDX license list import
Compliance report
License Compliance (deprecated)
Description templates
Deploy keys
Deploy tokens
File finder
Import projects
Bitbucket Cloud
Bitbucket Server
ClearCase
CVS
FogBugz
Gitea
GitHub
GitHub import Rake task
GitLab
Troubleshooting
Rate limits for project and group imports and exports
Decompressed archive size limits
Rake tasks
Jira
Perforce Helix
Repo by manifest file
Repo by URL
TFVC
System notes
Plan and track work
Labels
Iterations
Tutorial: Use GitLab to run an Agile iteration
Milestones
Burndown and burnup charts
Issues
Create issues
Manage issues
Confidential issues
Crosslinking issues
CSV export
CSV import
Design management
Due dates
Emoji reactions
Issue boards
Tutorial: Set up issue boards for team hand-off
Multiple assignees
Linked issues
Service Desk
Rake tasks
Sorting and ordering issue lists
Weight
Zoom meetings in issues
Comments and threads
Tasks
Requirements
Time tracking
Customer relations (CRM)
Wikis
Group wikis
Epics
Manage epics
Linked epics
Epic boards
Roadmaps
Planning hierarchies
Objectives and key results (OKR)
Keyboard shortcuts
Quick actions
Autocomplete characters
Markdown
AsciiDoc
CSV files
To-Do List
Using Git
Tutorial: Make your first Git commit
Concepts
Installing Git
Command line Git
GitLab Flow
Add file to repository
Partial clone
Rebase and force-push
Undo options
Frequently used commands
Git add
Unstage
Git stash
Push options
Roll back commits
Cherry-pick a commit
Troubleshooting
Build your application
Repositories
Code owners
Syntax and errors
Snippets
Branches
Tags
Changelogs
Default branch
Feature branch workflow
Forking workflow
GeoJSON files
Git attributes
Git LFS
Jupyter notebook files
Locked files
File Blame
File History
Mirroring
Bidirectional mirroring
Pull mirroring
Push mirroring
Protected branches
Protected tags
Push rules
Reduce repository size
Sign commits with GPG
Sign commits with SSH keys
Sign commits and tags with X.509
X509 signatures Rake task
Syntax highlighting
Web Editor
Web IDE
Remote development
Tutorial: Connect a remote machine to the Web IDE
Workspaces
Managing large repositories
Merge requests
Workflows
Collaborate across forks
Create merge requests
Commits
Changes
Approvals
Approval rules
Approval settings
Commit message templates
Draft merge requests
Confidential merge requests
Reviewing and managing merge requests
Suggestions
Merge request widgets
Merge methods
Squash and merge
Auto-merge
Merge conflicts
Reverting changes
Cherry pick changes
Versions
Export merge requests to CSV
External status checks
Merge request dependencies
CI/CD
Tutorial: Create your first pipeline
Tutorial: Create a complex pipeline
CI/CD concepts
Migrate from CircleCI
Migrate from Jenkins
Enable or disable CI/CD
Pipelines
Scheduled pipelines
Trigger a pipeline
Customize pipeline configuration
Pipeline architectures
Pipeline efficiency
Pipeline resource groups
Directed acyclic graph (DAG)
Downstream pipelines
Merge request pipelines
Merged results pipelines
Merge trains
Jobs
Choose when jobs run
CI/CD job token
Access a terminal for a running job
Format scripts and job logs
Git submodules
Variables
Predefined variables
Where variables can be used
Secure Files
Cache and artifacts
Job artifacts
Troubleshooting job artifacts
.gitlab-ci.yml
.gitlab-ci.yml reference
Optimize your YAML files
Validate syntax
Pipeline Editor
Artifacts reports
Include examples
Workflow examples
CI/CD Components
Docker
Run CI/CD jobs in Docker containers
Use Docker to build Docker images
Authenticate with registry
Docker Layer Caching
Use kaniko to build Docker images
Services
MySQL service
PostgreSQL service
Redis service
GitLab as a service
Auto DevOps
Requirements
Stages
Customize
CI/CD variables
Multiple Kubernetes clusters
Upgrade PostgreSQL
Prepare for deployment
Upgrade Auto Deploy dependencies
Deploy to GKE
Deploy to EKS
Deploy to ECS
Deploy to EC2
Troubleshooting
Testing
Accessibility testing (deprecated)
Browser performance testing (deprecated)
Code coverage
Code quality
Fail fast testing
Load performance testing (deprecated)
Metrics reports
Test cases
Test coverage visualization
Unit test reports
Unit test report examples
SSH keys
External secrets
ID token authentication
Connect to cloud services
Authenticating with HashiCorp Vault
Configure OpenID Connect in AWS
Configure OpenID Connect in Azure
Configure OpenID Connect with Google Cloud
ChatOps
Mobile DevOps
External repository integrations
Bitbucket Cloud
GitHub
CI/CD examples
Deployment with Dpl
End-to-end testing
NPM with semantic-release
PHP with PHPunit and atoum
PHP with NPM and SCP
PHP with Laravel and Envoy
Troubleshooting
Runners
Runner SaaS
Linux
GPU
macOS
Windows
The scope of runners
Register a runner
Generate runner tokens
Migrate to new runner registration workflow
Examples
Runner executors
Custom
libvirt
LXD
Docker
Docker Machine
Docker Autoscaler
Instance
Kubernetes
Shell
Supported shells
SSH
Parallels
VirtualBox
Configure runners
Scale a fleet of runners
Tutorial: Configure GitLab Runner to use the Google Kubernetes Engine
Best practices for large repositories
GitLab Pages
Tutorial: Create website from scratch
Tutorial: Build, test, and deploy your Hugo site
Create website from CI/CD template
Create website from forked sample project
Create website from project template
Create deployment for static site
Public folder
Default domain names and URLs
Custom domains
DNS records
SSL/TLS certificates
Let's Encrypt certificates
Access control
Redirects
Settings
Packages & Registries
Package Registry
Supported package managers
Supported functionality
Composer
Conan
Debian
Go Proxy
Helm
Maven
npm
NuGet
PyPI
Ruby gems
Yarn
Generic
Store all packages in one project
Monorepo workflows
Reduce Package Registry storage
Build packages
Container Registry
Authenticate
Build and push images
Delete images
Reduce Container Registry storage
Reduce Container Registry data transfers
Troubleshooting
Harbor Registry
Terraform module registry
Dependency Proxy
Reduce Dependency Proxy storage
Secure your application
Application security
Get started
Security Configuration
Container Scanning
Tutorial: Scan a Docker container for vulnerabilities
Dependency Scanning
Dependency Scanning Analyzers
Tutorial: Set up dependency scanning
Dependency List
Static Application Security Testing
Customize rulesets
SAST Analyzers
Infrastructure as Code (IaC) Scanning
Secret Detection
Automatic response to leaked secrets
Dynamic Application Security Testing (DAST)
DAST browser-based analyzer
Vulnerability checks
Troubleshooting
DAST proxy-based analyzer
Troubleshooting
Authentication
DAST API analyzer
Run DAST offline
API Security
API Discovery
Web API Fuzz Testing
HTTP Archive format
Coverage-guided fuzz testing
Tutorial: Perform fuzz testing in GitLab
Breach and Attack Simulation
Security Dashboard
Offline environments
Vulnerability Report
View vulnerabilities in a pipeline
Generate test vulnerabilities
Vulnerability Page
Vulnerability severity levels
CVE ID requests
Policies
Scan execution policies
Scan result policies
Tutorial: Set up a scan result policy
Security scanner integration
Secure and Govern glossary
Deploy and release your application
Environments and deployments
Environments Dashboard
Operations Dashboard
Dashboard for Kubernetes
Protected environments
Deployment safety
Deployment approvals
Roll out an application incrementally
Deploy to AWS
Deploy to Amazon ECS
Deploy to Heroku
External deployment tools
Configure Kubernetes deployments (deprecated)
Releases
Release CI/CD examples
Release CLI tool
Release fields
Release evidence
Review Apps
Feature flags
Monitor application performance
Error Tracking
Incident management
Alerts
Integrations
Incidents
Manage incidents
Timeline events
Linked resources
Incident management for Slack
On-call schedules
Escalation policies
Paging and notifications
Status page
Monitor runner performance
Manage your infrastructure
Infrastructure as Code
Terraform state
Terraform integration in merge requests
GitLab Terraform helpers
Terraform template recipes
Troubleshooting
Create Kubernetes clusters
Amazon EKS
Google GKE
Civo
Connect Kubernetes clusters
GitOps workflow
Flux
Tutorial: Set up Flux for GitOps
Use Helm charts
Manage Kubernetes secrets
Track cluster resources
Example GitOps repository structure
GitLab CI/CD workflow
Manage cluster applications
Install cert-manager
Install Ingress
Install GitLab Runner
Install Vault
Install the agent for Kubernetes
Work with the agent for Kubernetes
Grant users Kubernetes access
Operational container scanning
Troubleshooting
Migrate to the agent for Kubernetes
Runbooks
Analyze GitLab usage
Analytics dashboards
CI/CD analytics
Code review analytics
Contribution analytics
DevOps adoption by instance
DevOps adoption by group
DORA metrics
Insights for projects
Insights for groups
Issue analytics for projects
Issue analytics for groups
Merge request analytics
Product analytics
Productivity analytics
Repository analytics for projects
Repository analytics for groups
Usage trends
Value stream analytics for projects
Value stream analytics for groups
Value streams dashboard
Instance-level analytics
Audit events
Audit event streaming
Examples
GraphQL API
Audit reports
Metrics
Configure GitLab
Configure Grafana
GitHub imports
GitLab exporter
GitLab Prometheus metrics
Self monitoring project
IP allowlist endpoints
Node exporter
PGBouncer exporter
PostgreSQL server exporter
Prometheus
Performance bar
Performance monitoring
Redis exporter
Registry exporter
Usage statistics
Web exporter
Experiment, Beta, GA support
AI/ML powered features
Develop
Integrations
Akismet
Apple App Store
Arkose Protect
Asana
Atlassian Bamboo
Datadog
Diagrams.net
Discord Notifications
Elasticsearch
Troubleshooting
Emails on push
External issue trackers
Bugzilla
ClickUp
Custom issue tracker
Engineering Workflow Management (EWM)
Redmine
YouTrack
ZenTao (deprecated)
GitHub
GitLab for Slack app
Gitpod
Gmail actions
Google Chat
Google Play
Harbor
irker (IRC gateway)
Jenkins
Jira
Jira issue integration
Jira issue management
Tutorial: Create Jira credentials
Jira development panel
GitLab for Jira Cloud app
Jira DVCS connector
Troubleshooting
Troubleshooting
Kroki
Mailgun
Marketplace partners
Mattermost notifications
Mattermost slash commands
Microsoft Teams notifications
MLflow
Mock CI
Pipeline status emails
Pivotal Tracker
PlantUML
Project integration management
Project integrations
Prometheus
Sample data Rake task
Pumble
reCAPTCHA
Security partners
ServiceNow
Slack notifications (deprecated)
Slack slash commands
Slash commands in Mattermost and Slack
Sourcegraph
Squash TM
Telegram
Trello Power-Ups
Unify Circuit
Webex Teams
Webhooks
Webhook events
Rake tasks
REST API
REST API resources
.gitignore (templates)
.gitlab-ci.yml (templates)
Access requests
Agent for Kubernetes
Alert Management
Appearance (application)
Applications
Audit events
Avatar
Badges (project)
Badges (group)
Branches
Broadcast messages
Commits
Composer
Conan
Container Registry
Custom attributes
Dashboard annotations
Debian
Debian group distributions
Debian project distributions
Dependencies
Dependency Proxy
Deploy keys
Deploy tokens
Deployments
Discussions
Dockerfile (templates)
DORA4 metrics
Emoji reactions
Environments
Epics
Error tracking
Events
Experiments
External status checks
Feature flags
Feature flag user lists
Freeze periods
Geo nodes
Geo sites
GitLab Pages
Go Proxy
Group access tokens
Group activity analytics
Group epic boards
Group Import/Export
Group-level protected branches
Group migration by direct transfer
Group relations export
Group repository storage moves
Groups
Helm
Import
Instance-level CI/CD variables
Integrations
Invitations
Issue boards (project)
Issue boards (group)
Issues
Issues (epic)
Issues statistics
Iterations (project)
Iterations (group)
Jobs
Job artifacts
Job token scopes
Keys
Labels (project)
Labels (group)
License
Licenses (templates)
Linked epics
Links (issue)
Links (epic)
Lint .gitlab-ci.yml
Markdown
Marketplace
Maven
Member Roles
Members
Merge request approvals
Merge request context commits
Merge requests
Merge trains
Metadata
Milestones (project)
Milestones (group)
Namespaces
Notes (comments)
Draft notes
Notification settings
npm
NuGet
Packages
Pages domains
Personal access tokens
Pipelines schedules
Pipeline triggers
Pipelines
Plan limits
Product analytics
Project access tokens
Project aliases
Project import/export
Project relations export
Project remote mirrors
Project repository storage moves
Project statistics
Project templates
Project vulnerabilities
Projects
Protected branches
Project-level protected environments
Group-level protected environments
Protected tags
PyPI
Releases
Group releases
Release links
Repositories
Repository files
Repository submodules
Resource group
Resource iteration events
Resource label events
Resource milestone events
Resource state events
Resource weight events
Ruby gems
Runners
SAML
SCIM
Search
Search migrations
Secure files
Settings (application)
Sidekiq metrics
Sidekiq queues
Snippet repository storage moves
Snippets
Snippets (project)
Statistics (application)
Suggestions
System hooks
Tags
Terraform Registry
To-Do lists
Topics
Service Data
Users
User-starred metrics dashboards
Variables (project)
Variables (group)
Version
Visual Review discussions (deprecated)
Vulnerabilities
Vulnerability export
Vulnerability Findings
Wikis (group)
Wikis (project)
Deprecations and removals
OpenAPI
GraphQL API
Run GraphQL API queries and mutations
GraphQL reference
Create audit report (example)
Identify issue boards (example)
List branch rules for project (example)
Query users (example)
Use custom emojis (example)
Removed items
OAuth 2.0 identity provider API
GitLab CLI (glab)
Visual Studio Code extension
Code Suggestions
Contribute
Contribute to GitLab
Tutorial: Make a GitLab contribution
Architecture
Adding a new Service Component
Development Rake tasks
Mass insert Rails models
Development processes
AI features
Changelog entries
ChatOps on GitLab.com
Code review guidelines
Danger bot
Deprecation guidelines
FIPS compliance
Experiments
Implementing experiments
Testing experiments
Experiment code reviews
Experiment rollouts
Feature flags for GitLab development
Controlling feature flags
Feature flags API
Framework - DeclarativePolicy
Issues workflow
Labels
Merge request concepts
Merge request diffs development guide
Working with diffs
Application and rate limit guidelines
Frontend overview
Performance guidelines
Merge request workflow
Ruby upgrade guidelines
Secure partner onboarding process
Testing standards and styles
Flaky tests
Frontend testing standards and style guidelines
Review apps
Smoke tests
Testing best practices
Testing levels
Testing Rails migrations
Testing Rake tasks
Testing (contract)
Writing consumer tests
Writing provider tests
Testing (end to end)
Beginner's guide to writing end-to-end tests
Best practices when writing end-to-end tests
Dynamic element validation
Flows in GitLab QA
Page objects in GitLab QA
Resource class in GitLab QA
Migrate Capybara to Chemlab
Execution context selection
e2e:package-and-test
Running tests that require special setup
RSpec metadata for end-to-end tests
Style guide for writing end-to-end tests
Testing with feature flags
Test Infrastructure for Cloud Integrations
Troubleshooting
Translate GitLab
Externalization
Translation
Proofreading
Merging
Development style guides
Advanced search migration style guide
API style guide
Frontend style guides
Gemfile guidelines
Go standards and style guidelines
Dependency management in Go
Managing Go versions
GraphQL API style guide
Shell command guidelines
HTML style guide
JavaScript style guide
Python guidelines
RuboCop rule guidelines
Ruby style guide
SCSS style guide
Secure coding guidelines
Shell scripting standards and style guidelines
Vue style guide
Feature development
Advanced search
Approval rules
Audit events
Auto DevOps
Built-in project templates
CI/CD
Documenting keywords
Contribute to the CI/CD schema
CI/CD template development
Pipeline Wizard
New partitioned CI/CD tables
Code intelligence
Code Owners
Create: Source Code backend
Gitaly touch points
Source Code REST endpoints
Database
Adding database indexes
Adding required stops
Add a foreign key constraint to an existing column
Avoiding downtime in migrations
Batched background migrations
Case study - filtering by label
Case study - namespaces storage statistics
CI mirrored tables
ClickHouse
GitLab activity data in ClickHouse
Merge request analytics with ClickHouse
Optimizing query execution
Tiered storages in ClickHouse
Database Dictionary
Database Lab and Postgres.ai
Database load balancing
Database migration pipeline
Database review guidelines
Database check-migrations job
Delete existing migrations
Foreign keys and associations
Introducing a new database migration version
Layout and access patterns
Maintenance operations
Migrations style guide
Multiple databases
Loose Foreign Keys
Migrations for multiple databases
Ordering table columns
Pagination guidelines
Pagination performance guidelines
Keyset pagination
Post-deployment migrations
Query comments with Marginalia
Query Recorder
SQL guidelines
Strings and the Text data type
Swapping tables
Table partitioning
Troubleshooting and debugging
Understanding EXPLAIN plans
Design and UI
Distributed tracing
Frontend development
Accessibility
Architecture
Axios
Content Editor
Customizable dashboards
Dark mode
Dependencies
Design anti-patterns
Design patterns
Development process
Event tracking
Emojis
Frontend FAQ
GraphQL
HAML
Icons and SVG illustrations
Keyboard shortcuts
Logging
Merge request widget extensions
Performance
Principles
Registry architecture
Security
Source editor
Tooling
Troubleshooting
ViewComponent
Vuex
Vue
Vue 3 migration
Widgets
Geo
Geo framework
Geo proxying
Git LFS
Git object deduplication
Gitaly
GitLab Flavored Markdown (GLFM)
GitLab Flavored Markdown (GLFM) specification guide
GitLab Shell
Features
GitLab-sshd
Processes
GraphQL
GraphQL authorization
GraphQL BatchLoader
GraphQL pagination
GraphQL Pro
GraphQL API merge request checklist
Import (GitHub)
Import (group migration by direct transfer)
Import (project import by file export)
Import (test project)
Identity verification
Integrations
Internal API
Internal allowed API
Internal users
Issuable-like Rails models utilities
Issue types
Jenkins in local environments
Jira development environment
JSON guidelines
Kubernetes integration
Logging
Observability for stage groups
Dashboards
Stage group dashboard
Error budget detail
Package
Package settings
Package structure
Support new formats
Cleanup policies
Debian repository
Dependency proxy
Harbor registry
Permissions
Product Qualified Lead (PQL)
Pry debugging
VS Code debugging
Build and deploy real-time view components
Redis
Sec section
Analyzer development guide
CycloneDX property taxonomy
Security report ingestion
Token Revocation API
Service Ping
Metrics lifecycle
Implement Service Ping
Metrics instrumentation
Metrics dictionary guide
Metrics dictionary
Metrics Performance Indicator
Review guidelines
Troubleshooting
Sidekiq
Compatibility across updates
Job idempotency and job deduplication
Limited capacity worker
Logging
Worker attributes
Snowplow
Implement Snowplow
Snowplow Infrastructure
Schemas
Event dictionary guide
Event dictionary
Review guidelines
Troubleshooting
Spam protection and CAPTCHA
Model and services
REST API spam protection
GraphQL API spam protection
Web UI spam protection
Exploratory testing
Uploads
Adding new uploads
Value Stream Analytics
Verify stage
Wikis
Work items and work item types
Workhorse
Adding new features to Workhorse
Configuration
Features that rely on Workhorse
Websocket channel support
Prometheus metrics
Organization
User experience
GitLab Development Kit
GitLab project pipelines
Contribute to GitLab Runner
Review GitLab Runner
Add new Windows version support for Docker executor
Contribute to GitLab Pages
Using dnsmasq to dynamically handle GitLab Pages subdomains
Contribute to GitLab Distribution
Contribute to Omnibus GitLab
Get started
Build locally
Build Omnibus GitLab package
Build all-in-one Docker image
Information for GitLab team members
Set up a development environment
CI variables
Change package behavior
Change YAML config options
Add deprecation messages
Add new gitlab-ctl commands
Add new services
Add new software definitions
Create patches
Add or remove configuration options
Manage PostgreSQL versions
Omnibus mirror
Version format for the packages and Docker images
Pipelines
Work with public_attributes.json
Upgrade Chef
Handle vulnerabilities
Handle broken master pipelines
Deprecate and remove support for an OS
Contribute to GitLab Helm charts
Architecture of Cloud native GitLab Helm charts
Backup and Restore
Goals
Architecture
Design Decisions
Resource Usage
Environment setup
Style guide
Versioning and release
Troubleshooting
Contribute to GitLab Operator
Contribute to GitLab Design System
Contribute to documentation
Contribute
Style guide
Recommended word list
Topic types
Concepts
Tasks
Reference
Troubleshooting
Tutorials
Glossaries
Document product versions
Document feature flags
Document Experiment and Beta features
Global navigation
Workflow
Drawer content
Testing
Site architecture
Folder structure
Deployment process
Documentation review apps
Redirects
Create a GraphQL example page
Documenting REST API resources