[{"data":1,"prerenderedAt":919},["ShallowReactive",2],{"/en-us/topics/microservices/":3,"navigation-en-us":260,"banner-en-us":677,"footer-en-us":694,"next-steps-en-us":904},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"seo":8,"content":11,"_id":254,"_type":255,"title":7,"_source":256,"_file":257,"_stem":258,"_extension":259},"/en-us/topics/microservices","topics",false,"",{"title":9,"ogTitle":9,"description":10,"ogDescription":10},"What are microservices?","Discover Microservices, a modern software architecture design that splits applications into independent parts for faster innovation and massive scale!",[12,22,28,145,195,252],{"type":13,"componentName":13,"componentContent":14},"CommonBreadcrumbs",{"crumbs":15},[16,20],{"title":17,"config":18},"Topics",{"href":19},"/topics/",{"title":21},"Microservices",{"type":23,"componentName":23,"componentContent":24},"TopicsHero",{"title":9,"text":25,"config":26},"Microservices are a modern interpretation of service-oriented architectures in which an application is split into many small services, allowing teams to innovate faster and achieve massive scale.\n",{"id":27,"twoColumns":6},"what-are-microservices?",{"type":29,"componentName":29,"componentContent":30},"CommonSideNavigationWithTree",{"anchors":31,"components":78},{"text":32,"data":33},"On this page",[34,38,42,46,50,54,58,62,66,70,74],{"text":35,"config":36},"Microservices explained",{"href":37},"#microservices-explained",{"text":39,"config":40},"Monolithic architectures vs. microservices architectures",{"href":41},"#monolithic-architectures-vs-microservices-architectures",{"text":43,"config":44},"Microservice core components",{"href":45},"#microservice-core-components",{"text":47,"config":48},"Microservice characteristics",{"href":49},"#microservice-characteristics",{"text":51,"config":52},"Microservice architecture use cases",{"href":53},"#microservice-architecture-use-cases",{"text":55,"config":56},"Benefits of a microservices architecture",{"href":57},"#benefits-of-a-microservices-architecture",{"text":59,"config":60},"Challenges of a microservices architecture",{"href":61},"#challenges-of-a-microservices-architecture",{"text":63,"config":64},"Business value of microservices",{"href":65},"#business-value-of-microservices",{"text":67,"config":68},"The future of microservices architecture",{"href":69},"#the-future-of-microservices-architecture",{"text":71,"config":72},"Using GitLab with microservices",{"href":73},"#using-git-lab-with-microservices",{"text":75,"config":76},"GitLab key benefits",{"href":77},"#git-lab-key-benefits",[79,85,90,95,100,105,110,115,120,125,130,135],{"type":80,"componentName":80,"componentContent":81},"TopicsCopy",{"header":35,"text":82,"config":83},"Many businesses built their original services using a monolithic application architecture — in other words, all the architecture components reside within a single infrastructure. When developers use a microservices architecture, they break out all of the system components and deploy them as individual services. The services communicate with each other using API calls.\n\nThe result is a pluggable architectural style that allows for fast and cost-efficient upgrades. If you need to scale only one area of the system, it’s easier and less expensive than scaling the entire system. Developers use container orchestration tools and Kubernetes to appropriately allocate processing power and whatever other resources they require. These services run in a container on a cloud-based server.\n",{"id":84},"microservices-explained",{"type":80,"componentName":80,"componentContent":86},{"header":39,"text":87,"config":88},"You can understand [microservices architecture](/direction/microservices/) by comparing it to a legacy monolithic application architecture. With a monolithic architectural style, all the individual components are part of a single unit. Everything is developed, deployed, and scaled together. Teams must write the entire application in a single language with a single runtime.\n\nThat means different teams working on different app components need to coordinate so they don't affect each other’s work. For example, one part of the app may depend on a module that needs a specific version, say 1.8, while another team needs the same module but requires version 1.7 because 1.8 is incompatible with another dependency. In a monolithic app, you have to pick one or the other. Similarly, monolithic apps deploy everything as a single application, requiring testing and deploying code together.\n\nWith microservices, each component is broken out and deployed individually as services that communicate with each other via API calls.\n\n![monolith-vs-microservices-large](https://res.cloudinary.com/about-gitlab-com/image/upload/v1751041219/iynuvgr7didgcffqfl8r.png)\n",{"id":89},"monolithic-architectures-vs-microservices-architectures",{"type":80,"componentName":80,"componentContent":91},{"header":43,"text":92,"config":93},"Microservices maximize application reliability and deployment velocity. This is particularly important in a marketplace that’s moving and evolving faster than ever. Microservices’ containerized architecture moves apps anywhere without altering or disrupting the environment, facilitating speed and reducing downtime.\n\nLet's look at the core components of a microservices architecture:\n\n1. **Clients**: Client apps usually must consume functionality from multiple microservices and require frequent updates.\n1. **Databases**: A service API updates microservices databases by carrying all remote services supporting inter-process communications for different stacks.\n1. **API gateway**: An API gateway is a microservices design pattern that's a vital single app entry point for routing requests and protocol translation.\n1. **Identity providers**: An identity microservice must permit server-to-server and user-driven access to identity data.\n1. **Messaging formats**: Microservices communicate with synchronous or asynchronous microservice architecture patterns.\n1. **Static content**: Clients receive static content via cloud-based storage services and content delivery networks.\n1. **Management**: This component allows business users to configure services during run-time.\n1. **Service discovery**: A service discovery mechanism is required to request service.\n",{"id":94},"microservice-core-components",{"type":80,"componentName":80,"componentContent":96},{"header":47,"text":97,"config":98},"[Martin Fowler's quintessential article on microservices](https://martinfowler.com/articles/microservices.html) defines nine components that most microservice architectures have in common.\n\n### 1. Componentization via services\nBy nature, microservices architectures are broken down into component services. As such, each service can be designated, deployed, refined, and redeployed independently without affecting the environment. This means it’s usually possible to change a service instead of redeploying an entire app.\n\n### 2. Organized around business capabilities\nWith the monolithic approach, tech teams focused separately on tech-related capabilities such as UI, databases, and server-side logic. On the other hand, microservices organize cross-functional teams around business capabilities and priorities. Teams can then design products based on individual services that communicate using a message bus.\n\n### 3. Products not projects\nIn the past, app developers used the project model that tasked teams to build software, which then went to a maintenance organization upon completion. The microservices architecture favors a team owning the product over its lifetime. This allows developers to interact with their products in new ways, seeing how they behave in production and increasing user contact. It also empowers engineers and businesses to increase collaboration and understand each other’s fields.\n\n### 4. Smart endpoints and dumb pipes\nMicroservices have a lot in common with the traditional UNIX system. They receive a request, process it, and generate an appropriate response. Fowler refers to this approach as “smart endpoints and dumb pipes.” The infrastructure is usually “dumb,” as it serves solely as a message router, and all the smarts reside at the endpoints producing and consuming endpoints.\n\n### 5. Decentralized governance\nDecentralized governance is a microservice architecture’s default structure because single-technology platforms often lead to over-standardization. A major advantage of microservices as opposed to monoliths is using different programming languages and technologies where they’re best suited. For example, Spring Boot microservices can build an app for one component, with Spring Cloud comprising another.\n\n### 6. Decentralized data management\nMost microservices allow each component to manage its own database from decentralized data management. You can always use the best data store for a specific project while removing the time-consuming task of shared database upgrades.\n\n### 7. Infrastructure automation\nCI/CD experts use infrastructure automation in microservices. It lessens developers' workloads and significantly improves deployment timeline efficiency.\n\n### 8. Design for failure\nLike the best businesses, microservices have resilience in mind. As unique and diverse services must communicate, failure is likely. This is the main disadvantage of microservices compared to monoliths because the solution requires additional complexity.\n\nSophisticated monitoring and logging setups are necessary to prevent failure from impacting consumers. While this requires more work for engineers, it means fail resistance is well-developed.\n\n### 9. Evolutionary design\nIn such a fast-paced tech industry, evolutionary design is no longer a luxury — it's a necessity. New electronic devices hit the market each year, and your apps must be ready to accommodate them. The deconstructed design of microservices means you can give your apps a makeover without redeployment.\n\nFowler went into more detail about each of these components in this talk from GOTO.\n",{"id":99},"microservice-characteristics",{"type":80,"componentName":80,"componentContent":101},{"header":51,"text":102,"config":103},"Microservices designs are agile and flexible and enable minimal downtime for maintenance, repairs and updates.\n\nSome key use cases for microservices include:\n### 1. Data processing\nApps running on microservice architecture can handle more concurrent requests in less time, making them more efficient.\n### 2. Website migration\nMicroservices avoid site UI, structure and/or domain site migration downtime.\n### 3. Large-scale media\nPlatforms can handle an extreme number of requests for different subdomains without errors or delays.\n### 4. Invoices and transactions\nMicroservices can help make transactions more robust with reduced app failure, allowing companies to scale up without redeploying.\n### 5. Outdated systems\nDeveloping a new containerized system is more efficient and effective than updating old, clunky monoliths.\n",{"id":104},"microservice-architecture-use-cases",{"type":80,"componentName":80,"componentContent":106},{"header":55,"text":107,"config":108},"[Implementing a microservices architecture](/blog/strategies-microservices-architecture/), or decomposing a legacy monolith into microservices, can increase velocity, flexibility, and scalability, often at the cost of simplicity. Monoliths are straightforward to build, deploy, and debug, but hard to scale. While a microservice architecture is more complex, there are several benefits for engineers:\n\n### Independent deployment\nEach microservice must be a full stack to function correctly. DevOps teams can easily fix errors on a single microservice without impacting the whole environment.\n\n### Scalability\nIn a monolith, all application elements must scale together — meaning some parts could have to scale unnecessarily. With independent components, each microservice can scale individually according to its load. Teams building apps with a microservices architecture can change each service without disrupting the rest of the app. Programmers can work in parallel to identify hot services, update functionality, and scale selected services.\n\n### Tech stack freedom\nReliance on a singular tech stack for the entire application is one of the most limiting features of a monolithic architecture. With microservices, developers can build an app using the right programming language, framework, databases, and frontend and backend tools for the job. This avoids having to compromise on a standardized stack that’s a jack-of-all-trades and master of none.\n\n### Fault isolation\nA single fault often means an entire monolith app fails. Microservices isolate faults to their components so the whole application isn’t affected. When one microservice fails, the rest of the application can remain online. It’s a good idea to display the status of each microservice on a dashboard of some kind so that maintenance personnel can identify issues and address problems quickly. Fixing issues can be as simple as moving a slider to bring an additional server online with on-demand virtualization.\n\n### Productivity\nMicroservices reduce silos and promote cross-functional teamwork for today’s distributed and remote workforces. They can be tested independently while developers handle other aspects, streamlining quality assurance. For engineers, microservices architectures allow for the building of scalable and resilient services that are easy to deploy.\n\nWith continuous delivery, businesses can test functionalities by making different versions of services available to different subsets of their users. Even enterprises with existing monolithic software are exploring ways to modernize their stack with microservices.\n",{"id":109},"benefits-of-a-microservices-architecture",{"type":80,"componentName":80,"componentContent":111},{"header":59,"text":112,"config":113},"Microservices bring the benefits of resiliency and scalability. However, making small independent services work together can be challenging.\n\nLet’s take a quick look at what you should keep in mind.\n\n- Complexity: As the number of microservices increases, they can become more complex to manage and orchestrate. Infrastructure automation and CI/CD are key.\n- Data consistency: Microservices work together within an extensive system while maintaining their own data. That means there will be common data across multiple services. Changes must be replicated across all consumer services whenever there are changes to such common data.\n- Risk of communication failure: Unlike in-process function calls, calls to other services can fail over the network. That’s a necessary trade-off with the resiliency and scalability gained from the microservices architecture. To increase resiliency, you can use bulkhead and circuit breaker patterns.\n",{"id":114},"challenges-of-a-microservices-architecture",{"type":80,"componentName":80,"componentContent":116},{"header":63,"text":117,"config":118},"Today, microservices architectures are prevalent throughout the business world — many companies are either already utilizing microservices or plan to soon. Microservices save money, reduce engineering headaches, and minimize downtime.\n\nFor businesses of all sizes, the time is now. There has never been a better moment to move your architecture from a monolithic structure to one relying on microservices. It will save you money in the long run, make your business operate more efficiently, and keep your customers happier. Microservices are the architecture of the future, and it’s time that you find out how they can help your business.\n\nMicroservices have a number of business benefits compared to monoliths. They promote a symbiotic relationship between developers and business leaders, leading to better outcomes. Microservices promote:\n\n1. Faster pace of innovation: Their evolutionary design makes it easy to change and upgrade application components.\n2. Greater stability/resiliency: Microservices practically eliminate downtime because, unlike monolithic architectures, services are separate and developers can update one component at a time.\n3. Scalability: Development teams can work on single components without impacting the entire environment, allowing them to better keep up with business demands.\n4. Lower costs and better revenue: Microservices need less overall infrastructure, minimize downtime, and improve stability for enhanced customer experience. They also reduce prototype to deployment timeframes.\n",{"id":119},"business-value-of-microservices",{"type":80,"componentName":80,"componentContent":121},{"header":67,"text":122,"config":123},"As more businesses and individuals rely on SaaS applications and the complexity of application development increases, the need for availability and scalability is higher than ever. Supporting services like scalable databases, continuous delivery, observability tools, and data and event streaming are also growing rapidly.\n\nEngineers are continually gaining skills to help them overcome these challenges. Meanwhile, microservices architecture and network infrastructure are still maturing. It’s easy to foresee a future where microservice applications become easier to maintain and develop and provide even more value to businesses.\n",{"id":124},"the-future-of-microservices-architecture",{"type":80,"componentName":80,"componentContent":126},{"header":71,"text":127,"config":128},"With GitLab, you can commit your code and have the tools you need in a single application. No more stitching together 10 tools for every project.\n\nUsing a [DevOps platform](/topics/devops-platform/) to manage your microservices helps you avoid information silos. Increasing visibility among teams and making handoffs easier leads to a faster DevOps lifecycle while also ensuring that your projects deploy and remain stable.\n\nGitLab simplifies microservice orchestration with:\n\n1. [Built-in CI/CD](/solutions/continuous-integration/): As Fowler points out, infrastructure automation using continuous delivery and deployment is necessary for microservices. GitLab’s built-in CI/CD is ideal for businesses looking to leverage microservices.\n1. [Built-in container registry](https://docs.gitlab.com/ee/user/packages/container_registry/index.html) and a robust [Kubernetes integration](/solutions/kubernetes/): While microservices architecture can be used with legacy virtual machine (VM) technology, containers and Kubernetes make building microservices significantly easier. GitLab is designed to work well with Kubernetes.\n1. [Built-in monitoring](/stages-devops-lifecycle/monitor/): Monitoring is critical to a successful operation. GitLab’s monitoring capabilities leveraging Prometheus make GitLab ideal for microservices.\n1. [Multi-project pipelines](/blog/use-multiproject-pipelines-with-gitlab-cicd/): GitLab supports running pipelines with cross-project dependencies, making interactions between different repositories easy to manage.\n1. Monorepo support and the ability to [run a pipeline only when code in a specific directory changes](https://docs.gitlab.com/ee/ci/yaml/#only-and-except-simplified): This reduces wasted time running pipelines across the entire repository.\n1. [Group-level Kubernetes clusters](https://docs.gitlab.com/ee/user/group/clusters/): Multiple projects can integrate with a single Kubernetes cluster.\n",{"id":129},"using-git-lab-with-microservices",{"type":80,"componentName":80,"componentContent":131},{"header":75,"text":132,"config":133},"GitLab is a single DevOps platform attracting top developers looking to collaborate and improve. Below are some key benefits of becoming a GitLab advocate:\n\n* No switching between apps:  Developers don’t need to constantly context-switch, making it easier to focus and stay on task. Additionally, you can easily link issues to work, increase productivity, and eliminate software engineers’ main bugbears.\n* Reduce your workload: GitLab makes it easier to automate tasks so that you can focus on more demanding, results-based activities. Repetitive manual tasks take the joy out of a developer’s workday. Automate tasks to improve work satisfaction and productivity.\n* Collaboration and transparency: Collaboration and transparency are key benefits of the GitLab platform. Transparency between developer and customer facilitates collaboration for quick, easy fixes and less communication.\n* Be part of the community: All developers are free to contribute to GitLab’s open source core to improve the app. It’s a warm, friendly, and highly responsive community that welcomes new community members and helps them learn the ropes.\n* Learn cutting-edge software development practices: Coding and application development is one of the fastest-growing fields in an increasingly fast-paced world. GitLab updates its community on all the latest developments and helps them learn best practices.\n",{"id":134},"git-lab-key-benefits",{"type":136,"componentName":136,"componentContent":137},"TopicsCallToAction",{"title":138,"subtitle":139,"text":140,"primaryButton":141},"Start your cloud native transformation","Build, test, deploy, and monitor your code from a single application.","Hear how Ask Media Group migrated from on-prem servers to the AWS cloud with GitLab tools and integrations. Join us and learn from their experience.",{"text":142,"config":143},"Save your spot!",{"href":144},"/webcast/cloud-native-transformation/",{"type":146,"componentName":146,"componentContent":147},"CommonResourcesContainer",{"header":148,"tabs":149},"Related Resources",[150,172],{"name":151,"items":152,"config":171},"Videos",[153,163],{"header":154,"type":155,"image":156,"link":159},"Mastering Chaos - A Netflix Guide to Microservices","Video",{"altText":154,"config":157},{"src":158},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158649/Website/Topics/mastering-chaos.jpg",{"text":160,"config":161},"Watch now",{"href":162,"icon":155,"modal":6},"https://www.youtube.com/embed/CZ3wIuvmHeM",{"header":164,"type":155,"image":165,"link":168},"Guilt's move from monolith to microservices",{"altText":164,"config":166},{"src":167},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158653/Website/Topics/from-monolith-to-microservices.jpg",{"text":160,"config":169},{"href":170,"icon":155,"modal":6},"https://www.youtube.com/embed/C4c0pkY4NgQ",{"key":151},{"name":173,"items":174,"config":194},"Articles",[175,186],{"header":176,"type":177,"image":178,"link":181},"How to break a Monolith into Microservices","Article",{"altText":176,"config":179},{"src":180},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158657/Website/Topics/resources_8.jpg",{"text":182,"config":183},"Learn more",{"href":184,"icon":185,"modal":6},"https://martinfowler.com/articles/break-monolith-into-microservices.html","Blog",{"header":187,"type":177,"image":188,"link":191},"Evolution of business logic from monoliths through microservices, to functions",{"altText":187,"config":189},{"src":190},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158662/Website/Topics/resources_15.jpg",{"text":182,"config":192},{"href":193,"icon":185,"modal":6},"https://read.acloud.guru/evolution-of-business-logic-from-monoliths-through-microservices-to-functions-ff464b95a44d",{"key":173},{"type":146,"componentName":146,"componentContent":196},{"header":197,"tabs":198},"Suggested Content",[199],{"name":200,"items":201,"config":251},"resources",[202,211,219,227,235,243],{"header":203,"type":204,"image":205,"link":208},"Trends in Version Control Land: Microservices","Web",{"altText":203,"config":206},{"src":207},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158667/Website/Topics/trends-in-version-control-land-microservices-cover.jpg",{"text":182,"config":209},{"href":210,"icon":204,"modal":6},"/blog/trends-in-version-control-land-microservices/",{"header":212,"type":204,"image":213,"link":216},"It's raining repos: The microservices repo explosion, and what we're doing about it",{"altText":212,"config":214},{"src":215},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158671/Website/Topics/microservices-explosion.jpg",{"text":182,"config":217},{"href":218,"icon":204,"modal":6},"/blog/microservices-integrated-solution/",{"header":220,"type":204,"image":221,"link":224},"Implementing microservices architectures and deployment strategies",{"altText":220,"config":222},{"src":223},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158677/Website/Topics/resources_17.jpg",{"text":182,"config":225},{"href":226,"icon":204,"modal":6},"/blog/strategies-microservices-architecture/",{"header":228,"type":204,"image":229,"link":232},"How to manage Agile teams with microservices",{"altText":228,"config":230},{"src":231},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158681/Website/Topics/agilemultipleteams.jpg",{"text":182,"config":233},{"href":234,"icon":204,"modal":6},"/blog/manage-agile-teams-with-microservices/",{"header":236,"type":204,"image":237,"link":240},"From monolith to microservices: How to leverage AWS with GitLab",{"altText":236,"config":238},{"src":239},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158687/Website/Topics/askmediablog-.jpg",{"text":182,"config":241},{"href":242,"icon":204,"modal":6},"/blog/from-monolith-to-microservices-how-to-leverage-aws-with-gitlab/",{"header":244,"type":204,"image":245,"link":248},"What devs need to know about tomorrow's tech today",{"altText":244,"config":246},{"src":247},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749158692/Website/Topics/future-of-software-what-developers-need-to-know.png",{"text":182,"config":249},{"href":250,"icon":204,"modal":6},"/blog/how-tomorrows-tech-affects-sw-dev/",{"key":200},{"type":253,"componentName":253},"CommonNextSteps","content:en-us:topics:microservices:index.yml","yaml","content","en-us/topics/microservices/index.yml","en-us/topics/microservices/index","yml",{"_path":261,"_dir":262,"_draft":6,"_partial":6,"_locale":7,"data":263,"_id":673,"_type":255,"title":674,"_source":256,"_file":675,"_stem":676,"_extension":259},"/shared/en-us/main-navigation","en-us",{"logo":264,"freeTrial":269,"sales":274,"login":279,"items":284,"search":614,"minimal":645,"duo":664},{"config":265},{"href":266,"dataGaName":267,"dataGaLocation":268},"/","gitlab logo","header",{"text":270,"config":271},"Get free trial",{"href":272,"dataGaName":273,"dataGaLocation":268},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":275,"config":276},"Talk to sales",{"href":277,"dataGaName":278,"dataGaLocation":268},"/sales/","sales",{"text":280,"config":281},"Sign in",{"href":282,"dataGaName":283,"dataGaLocation":268},"https://gitlab.com/users/sign_in/","sign in",[285,328,426,431,535,595],{"text":286,"config":287,"cards":289,"footer":311},"Platform",{"dataNavLevelOne":288},"platform",[290,296,304],{"title":286,"description":291,"link":292},"The most comprehensive AI-powered DevSecOps Platform",{"text":293,"config":294},"Explore our Platform",{"href":295,"dataGaName":288,"dataGaLocation":268},"/platform/",{"title":297,"description":298,"link":299},"GitLab Duo (AI)","Build software faster with AI at every stage of development",{"text":300,"config":301},"Meet GitLab Duo",{"href":302,"dataGaName":303,"dataGaLocation":268},"/gitlab-duo/","gitlab duo ai",{"title":305,"description":306,"link":307},"Why GitLab","10 reasons why Enterprises choose GitLab",{"text":182,"config":308},{"href":309,"dataGaName":310,"dataGaLocation":268},"/why-gitlab/","why gitlab",{"title":312,"items":313},"Get started with",[314,319,324],{"text":315,"config":316},"Platform Engineering",{"href":317,"dataGaName":318,"dataGaLocation":268},"/solutions/platform-engineering/","platform engineering",{"text":320,"config":321},"Developer Experience",{"href":322,"dataGaName":323,"dataGaLocation":268},"/developer-experience/","Developer experience",{"text":325,"config":326},"MLOps",{"href":327,"dataGaName":325,"dataGaLocation":268},"/topics/devops/the-role-of-ai-in-devops/",{"text":329,"left":330,"config":331,"link":333,"lists":337,"footer":408},"Product",true,{"dataNavLevelOne":332},"solutions",{"text":334,"config":335},"View all Solutions",{"href":336,"dataGaName":332,"dataGaLocation":268},"/solutions/",[338,363,387],{"title":339,"description":340,"link":341,"items":346},"Automation","CI/CD and automation to accelerate deployment",{"config":342},{"icon":343,"href":344,"dataGaName":345,"dataGaLocation":268},"AutomatedCodeAlt","/solutions/delivery-automation/","automated software delivery",[347,351,355,359],{"text":348,"config":349},"CI/CD",{"href":350,"dataGaLocation":268,"dataGaName":348},"/solutions/continuous-integration/",{"text":352,"config":353},"AI-Assisted Development",{"href":302,"dataGaLocation":268,"dataGaName":354},"AI assisted development",{"text":356,"config":357},"Source Code Management",{"href":358,"dataGaLocation":268,"dataGaName":356},"/solutions/source-code-management/",{"text":360,"config":361},"Automated Software Delivery",{"href":344,"dataGaLocation":268,"dataGaName":362},"Automated software delivery",{"title":364,"description":365,"link":366,"items":371},"Security","Deliver code faster without compromising security",{"config":367},{"href":368,"dataGaName":369,"dataGaLocation":268,"icon":370},"/solutions/security-compliance/","security and compliance","ShieldCheckLight",[372,377,382],{"text":373,"config":374},"Application Security Testing",{"href":375,"dataGaName":376,"dataGaLocation":268},"/solutions/application-security-testing/","Application security testing",{"text":378,"config":379},"Software Supply Chain Security",{"href":380,"dataGaLocation":268,"dataGaName":381},"/solutions/supply-chain/","Software supply chain security",{"text":383,"config":384},"Software Compliance",{"href":385,"dataGaName":386,"dataGaLocation":268},"/solutions/software-compliance/","software compliance",{"title":388,"link":389,"items":394},"Measurement",{"config":390},{"icon":391,"href":392,"dataGaName":393,"dataGaLocation":268},"DigitalTransformation","/solutions/visibility-measurement/","visibility and measurement",[395,399,403],{"text":396,"config":397},"Visibility & Measurement",{"href":392,"dataGaLocation":268,"dataGaName":398},"Visibility and Measurement",{"text":400,"config":401},"Value Stream Management",{"href":402,"dataGaLocation":268,"dataGaName":400},"/solutions/value-stream-management/",{"text":404,"config":405},"Analytics & Insights",{"href":406,"dataGaLocation":268,"dataGaName":407},"/solutions/analytics-and-insights/","Analytics and insights",{"title":409,"items":410},"GitLab for",[411,416,421],{"text":412,"config":413},"Enterprise",{"href":414,"dataGaLocation":268,"dataGaName":415},"/enterprise/","enterprise",{"text":417,"config":418},"Small Business",{"href":419,"dataGaLocation":268,"dataGaName":420},"/small-business/","small business",{"text":422,"config":423},"Public Sector",{"href":424,"dataGaLocation":268,"dataGaName":425},"/solutions/public-sector/","public sector",{"text":427,"config":428},"Pricing",{"href":429,"dataGaName":430,"dataGaLocation":268,"dataNavLevelOne":430},"/pricing/","pricing",{"text":432,"config":433,"link":434,"lists":438,"feature":522},"Resources",{"dataNavLevelOne":200},{"text":435,"config":436},"View all resources",{"href":437,"dataGaName":200,"dataGaLocation":268},"/resources/",[439,472,494],{"title":440,"items":441},"Getting started",[442,447,452,457,462,467],{"text":443,"config":444},"Install",{"href":445,"dataGaName":446,"dataGaLocation":268},"/install/","install",{"text":448,"config":449},"Quick start guides",{"href":450,"dataGaName":451,"dataGaLocation":268},"/get-started/","quick setup checklists",{"text":453,"config":454},"Learn",{"href":455,"dataGaLocation":268,"dataGaName":456},"https://university.gitlab.com/","learn",{"text":458,"config":459},"Product documentation",{"href":460,"dataGaName":461,"dataGaLocation":268},"https://docs.gitlab.com/","product documentation",{"text":463,"config":464},"Best practice videos",{"href":465,"dataGaName":466,"dataGaLocation":268},"/getting-started-videos/","best practice videos",{"text":468,"config":469},"Integrations",{"href":470,"dataGaName":471,"dataGaLocation":268},"/integrations/","integrations",{"title":473,"items":474},"Discover",[475,480,484,489],{"text":476,"config":477},"Customer success stories",{"href":478,"dataGaName":479,"dataGaLocation":268},"/customers/","customer success stories",{"text":185,"config":481},{"href":482,"dataGaName":483,"dataGaLocation":268},"/blog/","blog",{"text":485,"config":486},"Remote",{"href":487,"dataGaName":488,"dataGaLocation":268},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":490,"config":491},"TeamOps",{"href":492,"dataGaName":493,"dataGaLocation":268},"/teamops/","teamops",{"title":495,"items":496},"Connect",[497,502,507,512,517],{"text":498,"config":499},"GitLab Services",{"href":500,"dataGaName":501,"dataGaLocation":268},"/services/","services",{"text":503,"config":504},"Community",{"href":505,"dataGaName":506,"dataGaLocation":268},"/community/","community",{"text":508,"config":509},"Forum",{"href":510,"dataGaName":511,"dataGaLocation":268},"https://forum.gitlab.com/","forum",{"text":513,"config":514},"Events",{"href":515,"dataGaName":516,"dataGaLocation":268},"/events/","events",{"text":518,"config":519},"Partners",{"href":520,"dataGaName":521,"dataGaLocation":268},"/partners/","partners",{"backgroundColor":523,"textColor":524,"text":525,"image":526,"link":530},"#2f2a6b","#fff","Insights for the future of software development",{"altText":527,"config":528},"the source promo card",{"src":529},"/images/navigation/the-source-promo-card.svg",{"text":531,"config":532},"Read the latest",{"href":533,"dataGaName":534,"dataGaLocation":268},"/the-source/","the source",{"text":536,"config":537,"lists":539},"Company",{"dataNavLevelOne":538},"company",[540],{"items":541},[542,547,553,555,560,565,570,575,580,585,590],{"text":543,"config":544},"About",{"href":545,"dataGaName":546,"dataGaLocation":268},"/company/","about",{"text":548,"config":549,"footerGa":552},"Jobs",{"href":550,"dataGaName":551,"dataGaLocation":268},"/jobs/","jobs",{"dataGaName":551},{"text":513,"config":554},{"href":515,"dataGaName":516,"dataGaLocation":268},{"text":556,"config":557},"Leadership",{"href":558,"dataGaName":559,"dataGaLocation":268},"/company/team/e-group/","leadership",{"text":561,"config":562},"Team",{"href":563,"dataGaName":564,"dataGaLocation":268},"/company/team/","team",{"text":566,"config":567},"Handbook",{"href":568,"dataGaName":569,"dataGaLocation":268},"https://handbook.gitlab.com/","handbook",{"text":571,"config":572},"Investor relations",{"href":573,"dataGaName":574,"dataGaLocation":268},"https://ir.gitlab.com/","investor relations",{"text":576,"config":577},"Trust Center",{"href":578,"dataGaName":579,"dataGaLocation":268},"/security/","trust center",{"text":581,"config":582},"AI Transparency Center",{"href":583,"dataGaName":584,"dataGaLocation":268},"/ai-transparency-center/","ai transparency center",{"text":586,"config":587},"Newsletter",{"href":588,"dataGaName":589,"dataGaLocation":268},"/company/contact/","newsletter",{"text":591,"config":592},"Press",{"href":593,"dataGaName":594,"dataGaLocation":268},"/press/","press",{"text":596,"config":597,"lists":598},"Contact us",{"dataNavLevelOne":538},[599],{"items":600},[601,604,609],{"text":275,"config":602},{"href":277,"dataGaName":603,"dataGaLocation":268},"talk to sales",{"text":605,"config":606},"Get help",{"href":607,"dataGaName":608,"dataGaLocation":268},"/support/","get help",{"text":610,"config":611},"Customer portal",{"href":612,"dataGaName":613,"dataGaLocation":268},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":615,"login":616,"suggestions":623},"Close",{"text":617,"link":618},"To search repositories and projects, login to",{"text":619,"config":620},"gitlab.com",{"href":282,"dataGaName":621,"dataGaLocation":622},"search login","search",{"text":624,"default":625},"Suggestions",[626,628,632,634,638,642],{"text":297,"config":627},{"href":302,"dataGaName":297,"dataGaLocation":622},{"text":629,"config":630},"Code Suggestions (AI)",{"href":631,"dataGaName":629,"dataGaLocation":622},"/solutions/code-suggestions/",{"text":348,"config":633},{"href":350,"dataGaName":348,"dataGaLocation":622},{"text":635,"config":636},"GitLab on AWS",{"href":637,"dataGaName":635,"dataGaLocation":622},"/partners/technology-partners/aws/",{"text":639,"config":640},"GitLab on Google Cloud",{"href":641,"dataGaName":639,"dataGaLocation":622},"/partners/technology-partners/google-cloud-platform/",{"text":643,"config":644},"Why GitLab?",{"href":309,"dataGaName":643,"dataGaLocation":622},{"freeTrial":646,"mobileIcon":651,"desktopIcon":656,"secondaryButton":659},{"text":647,"config":648},"Start free trial",{"href":649,"dataGaName":273,"dataGaLocation":650},"https://gitlab.com/-/trials/new/","nav",{"altText":652,"config":653},"Gitlab Icon",{"src":654,"dataGaName":655,"dataGaLocation":650},"/images/brand/gitlab-logo-tanuki.svg","gitlab icon",{"altText":652,"config":657},{"src":658,"dataGaName":655,"dataGaLocation":650},"/images/brand/gitlab-logo-type.svg",{"text":660,"config":661},"Get Started",{"href":662,"dataGaName":663,"dataGaLocation":650},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/compare/gitlab-vs-github/","get started",{"freeTrial":665,"mobileIcon":669,"desktopIcon":671},{"text":666,"config":667},"Learn more about GitLab Duo",{"href":302,"dataGaName":668,"dataGaLocation":650},"gitlab duo",{"altText":652,"config":670},{"src":654,"dataGaName":655,"dataGaLocation":650},{"altText":652,"config":672},{"src":658,"dataGaName":655,"dataGaLocation":650},"content:shared:en-us:main-navigation.yml","Main Navigation","shared/en-us/main-navigation.yml","shared/en-us/main-navigation",{"_path":678,"_dir":262,"_draft":6,"_partial":6,"_locale":7,"title":679,"button":680,"image":685,"config":689,"_id":691,"_type":255,"_source":256,"_file":692,"_stem":693,"_extension":259},"/shared/en-us/banner","is now in public beta!",{"text":681,"config":682},"Try the Beta",{"href":683,"dataGaName":684,"dataGaLocation":268},"/gitlab-duo/agent-platform/","duo banner",{"altText":686,"config":687},"GitLab Duo Agent Platform",{"src":688},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1753720689/somrf9zaunk0xlt7ne4x.svg",{"layout":690},"release","content:shared:en-us:banner.yml","shared/en-us/banner.yml","shared/en-us/banner",{"_path":695,"_dir":262,"_draft":6,"_partial":6,"_locale":7,"data":696,"_id":900,"_type":255,"title":901,"_source":256,"_file":902,"_stem":903,"_extension":259},"/shared/en-us/main-footer",{"text":697,"source":698,"edit":704,"contribute":709,"config":714,"items":719,"minimal":892},"Git is a trademark of Software Freedom Conservancy and our use of 'GitLab' is under license",{"text":699,"config":700},"View page source",{"href":701,"dataGaName":702,"dataGaLocation":703},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":705,"config":706},"Edit this page",{"href":707,"dataGaName":708,"dataGaLocation":703},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":710,"config":711},"Please contribute",{"href":712,"dataGaName":713,"dataGaLocation":703},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":715,"facebook":716,"youtube":717,"linkedin":718},"https://twitter.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[720,743,799,828,862],{"title":286,"links":721,"subMenu":726},[722],{"text":723,"config":724},"DevSecOps platform",{"href":295,"dataGaName":725,"dataGaLocation":703},"devsecops platform",[727],{"title":427,"links":728},[729,733,738],{"text":730,"config":731},"View plans",{"href":429,"dataGaName":732,"dataGaLocation":703},"view plans",{"text":734,"config":735},"Why Premium?",{"href":736,"dataGaName":737,"dataGaLocation":703},"/pricing/premium/","why premium",{"text":739,"config":740},"Why Ultimate?",{"href":741,"dataGaName":742,"dataGaLocation":703},"/pricing/ultimate/","why ultimate",{"title":744,"links":745},"Solutions",[746,751,753,755,760,765,769,772,776,781,783,786,789,794],{"text":747,"config":748},"Digital transformation",{"href":749,"dataGaName":750,"dataGaLocation":703},"/topics/digital-transformation/","digital transformation",{"text":373,"config":752},{"href":375,"dataGaName":373,"dataGaLocation":703},{"text":362,"config":754},{"href":344,"dataGaName":345,"dataGaLocation":703},{"text":756,"config":757},"Agile development",{"href":758,"dataGaName":759,"dataGaLocation":703},"/solutions/agile-delivery/","agile delivery",{"text":761,"config":762},"Cloud transformation",{"href":763,"dataGaName":764,"dataGaLocation":703},"/topics/cloud-native/","cloud transformation",{"text":766,"config":767},"SCM",{"href":358,"dataGaName":768,"dataGaLocation":703},"source code management",{"text":348,"config":770},{"href":350,"dataGaName":771,"dataGaLocation":703},"continuous integration & delivery",{"text":773,"config":774},"Value stream management",{"href":402,"dataGaName":775,"dataGaLocation":703},"value stream management",{"text":777,"config":778},"GitOps",{"href":779,"dataGaName":780,"dataGaLocation":703},"/solutions/gitops/","gitops",{"text":412,"config":782},{"href":414,"dataGaName":415,"dataGaLocation":703},{"text":784,"config":785},"Small business",{"href":419,"dataGaName":420,"dataGaLocation":703},{"text":787,"config":788},"Public sector",{"href":424,"dataGaName":425,"dataGaLocation":703},{"text":790,"config":791},"Education",{"href":792,"dataGaName":793,"dataGaLocation":703},"/solutions/education/","education",{"text":795,"config":796},"Financial services",{"href":797,"dataGaName":798,"dataGaLocation":703},"/solutions/finance/","financial services",{"title":432,"links":800},[801,803,805,807,810,812,814,816,818,820,822,824,826],{"text":443,"config":802},{"href":445,"dataGaName":446,"dataGaLocation":703},{"text":448,"config":804},{"href":450,"dataGaName":451,"dataGaLocation":703},{"text":453,"config":806},{"href":455,"dataGaName":456,"dataGaLocation":703},{"text":458,"config":808},{"href":460,"dataGaName":809,"dataGaLocation":703},"docs",{"text":185,"config":811},{"href":482,"dataGaName":483,"dataGaLocation":703},{"text":476,"config":813},{"href":478,"dataGaName":479,"dataGaLocation":703},{"text":485,"config":815},{"href":487,"dataGaName":488,"dataGaLocation":703},{"text":498,"config":817},{"href":500,"dataGaName":501,"dataGaLocation":703},{"text":490,"config":819},{"href":492,"dataGaName":493,"dataGaLocation":703},{"text":503,"config":821},{"href":505,"dataGaName":506,"dataGaLocation":703},{"text":508,"config":823},{"href":510,"dataGaName":511,"dataGaLocation":703},{"text":513,"config":825},{"href":515,"dataGaName":516,"dataGaLocation":703},{"text":518,"config":827},{"href":520,"dataGaName":521,"dataGaLocation":703},{"title":536,"links":829},[830,832,834,836,838,840,842,846,851,853,855,857],{"text":543,"config":831},{"href":545,"dataGaName":538,"dataGaLocation":703},{"text":548,"config":833},{"href":550,"dataGaName":551,"dataGaLocation":703},{"text":556,"config":835},{"href":558,"dataGaName":559,"dataGaLocation":703},{"text":561,"config":837},{"href":563,"dataGaName":564,"dataGaLocation":703},{"text":566,"config":839},{"href":568,"dataGaName":569,"dataGaLocation":703},{"text":571,"config":841},{"href":573,"dataGaName":574,"dataGaLocation":703},{"text":843,"config":844},"Sustainability",{"href":845,"dataGaName":843,"dataGaLocation":703},"/sustainability/",{"text":847,"config":848},"Diversity, inclusion and belonging (DIB)",{"href":849,"dataGaName":850,"dataGaLocation":703},"/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":576,"config":852},{"href":578,"dataGaName":579,"dataGaLocation":703},{"text":586,"config":854},{"href":588,"dataGaName":589,"dataGaLocation":703},{"text":591,"config":856},{"href":593,"dataGaName":594,"dataGaLocation":703},{"text":858,"config":859},"Modern Slavery Transparency Statement",{"href":860,"dataGaName":861,"dataGaLocation":703},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":863,"links":864},"Contact Us",[865,868,870,872,877,882,887],{"text":866,"config":867},"Contact an expert",{"href":277,"dataGaName":278,"dataGaLocation":703},{"text":605,"config":869},{"href":607,"dataGaName":608,"dataGaLocation":703},{"text":610,"config":871},{"href":612,"dataGaName":613,"dataGaLocation":703},{"text":873,"config":874},"Status",{"href":875,"dataGaName":876,"dataGaLocation":703},"https://status.gitlab.com/","status",{"text":878,"config":879},"Terms of use",{"href":880,"dataGaName":881,"dataGaLocation":703},"/terms/","terms of use",{"text":883,"config":884},"Privacy statement",{"href":885,"dataGaName":886,"dataGaLocation":703},"/privacy/","privacy statement",{"text":888,"config":889},"Cookie preferences",{"dataGaName":890,"dataGaLocation":703,"id":891,"isOneTrustButton":330},"cookie preferences","ot-sdk-btn",{"items":893},[894,896,898],{"text":878,"config":895},{"href":880,"dataGaName":881,"dataGaLocation":703},{"text":883,"config":897},{"href":885,"dataGaName":886,"dataGaLocation":703},{"text":888,"config":899},{"dataGaName":890,"dataGaLocation":703,"id":891,"isOneTrustButton":330},"content:shared:en-us:main-footer.yml","Main Footer","shared/en-us/main-footer.yml","shared/en-us/main-footer",{"_path":905,"_dir":262,"_draft":6,"_partial":6,"_locale":7,"header":906,"eyebrow":907,"blurb":908,"button":909,"secondaryButton":913,"_id":915,"_type":255,"title":916,"_source":256,"_file":917,"_stem":918,"_extension":259},"/shared/en-us/next-steps","Start shipping better software faster","50%+ of the Fortune 100 trust GitLab","See what your team can do with the intelligent\n\n\nDevSecOps platform.\n",{"text":270,"config":910},{"href":911,"dataGaName":273,"dataGaLocation":912},"https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com/","feature",{"text":275,"config":914},{"href":277,"dataGaName":278,"dataGaLocation":912},"content:shared:en-us:next-steps.yml","Next Steps","shared/en-us/next-steps.yml","shared/en-us/next-steps",1756472646795]