 Hi, this is Brian Walsh, Solutions Architect at GitLab. Today I'm going to walk through Cloud Native and how GitLab enables development teams to seamlessly utilize these tools and concepts to organize, develop, deploy, and monitor their applications. First, let's talk about Cloud Native as a concept. At the high level, Cloud Native is generally referred to as the modern development workflow and tools designed for building web applications. For example, utilizing tools for automating continuous integration, such as containers or Kubernetes, or enabling a better developer workflow by separating out monolith applications into separate concerns and distributions with microservices. Cloud Native has made waves in the industry as many large-scale applications have adopted the concepts. This is because the inherent advantages in the tools and workflow that allows development teams to focus on the application rather than the infrastructure. Some of these values include increased velocity. With built-in automation and working on logically separated services, Cloud Native teams are seeing a drastic decrease in cycle time, delivering business value faster. Next is cost efficiency. When architects utilize ephemeral containers, compute resources are only consumed when being used, reducing hardware overhead costs. And the simplified deployment with Kubernetes reduces the bottlenecks on deployments. And finally, Cloud Native reduces the overall risk of your application going down or becoming unavailable by providing on-demand scaling. So as the demand of your application increases, the resources will scale out so that your application will always be running at peak performance. And in the event that something does go wrong, Cloud Native resilient applications have features like auto remediation and simple redeployment methods that will reduce the impact of the overall outage. But for all the advantages, Cloud Native also introduces some complexities. Organizations have run into a new set of challenges that they need to overcome. Connecting multiple services for testing and deployment can lead to a disjointed experience and run into interdependency issues between the communication points. Process and culture play a huge role in the success of Cloud Native. As it relies on cross-functional teams to communicate across projects, without a solid process and a collaboration tool in place, Cloud Native can bring more pain than good. And for a team to move over to take advantage of Cloud Native, they still need to refactor their monolith application, which proved to be something that's much more complicated than a lift and shift approach. It requires new architecture, refactoring code, building out new deployment strategies, and a learning curve for the developers. An approach to monitoring also is required to change because traditional monolith applications are deployed to long-living servers within frequent updates over their lifespan, whereas Cloud Native technology architecture runs in ephemeral containers and infrastructure that can evolve relatively quickly. This adds to the complexity as these applications are regularly deployed to multiple availability zones, regions, or even multiple clouds. So this is where GitLab comes in, to relieve the burden and complexities of Cloud Native development. GitLab provides four key patterns, to automate, collaborate, integrate, and visualize, through a single, persistent UI. Let's take a look at these in more detail. First is automation. GitLab customer, Piusler, adapted GitLab for CI automation and took build times down from one hour to 30 seconds. Across the different development stages, automation is built in every step of the way. Everything from automation and security and performance job testing in our CI CD pipeline, to a built-in container registry where you can store and retrieve containers quickly and securely, to taking those containers and deploying them using a rollout strategy orchestrated and promoted through the GitLab UI. Cloud Native shift requires effective collaboration. X-Wade moved to a microservices approach, and their legacy tool chain was disconnected and caused friction points across the teams. When they adopted GitLab with a single application, developers utilized in-context collaboration tools, making it easy to focus on the right tasks. X-Wade went from releasing once a year to bi-weekly. Collaborating across multiple projects is easy with GitLab. The group level, HEPIX and Roadmaps, tie projects together to meet common goals. A bubbled-up view of important data like issues provides transparency, and multi-project milestones make it easy to visualize progress. As you drill down into your project, merge requests provide a centralized hub for cross-team collaboration. At the top of this page, CI generated reports for security and testing jobs give you in-context view of code help. In addition, a code review tool, with line-by-line commenting, makes it easy to collaborate and provide quality assurance. And the associated pipeline data is visible for each code commit associated to this branch. In addition to team collaboration, GitLab provides code-level collaboration by allowing the ability to trigger pipelines across multiple projects and visualizing that inside your UI. This provides the ability to run tests against other projects or automatically orchestrate deployments. Managing a development tool chain is complex and time-consuming. This is further amplified with cloud-native service-based approach, which causes even more siloed experience. GitLab's single application eliminates the need to jump between tools, provides turnkey integrations with cloud-native tooling. Ticketmaster, a GitLab customer, used to utilize a series of development tools by maintaining these tools, caused a lot of context switching and slowed the development team down. By migrating to GitLab, they reduced the number of tools in their tool chain and resulted in 15x faster builds. Given a project or group, Kubernetes clusters can be set up, linked and configured directly in the UI. With one-click installations of predefined apps, GitLab provides out-of-the-box functionality like Prometheus cluster monitoring, Ingress external access, or Knative. Furthermore, utilizing Knative's on your Kubernetes cluster allows for integration with serverless deployments to trigger mesh, providing a cloud-neutral approach to managing microservices without worrying about infrastructure. And when it comes time to test new features, feature flags can be set up and managed in GitLab, providing a code-level hook to deployed environments, allowing developers to enable and disable features in the UI without having to orchestrate a new deployment. As all of the projects and services are now configured, GitLab provides a centralized view into the entire lifecycle, particularly in security and monitoring. Cloud-native computing foundation chose GitLab CI to eliminate the complexities of managing multiple projects across multiple cloud providers. With Prometheus monitoring enabled in Kubernetes, monitoring metrics across multiple environments, the project is easy, providing tolerant configurations to alert the team if something goes wrong. Furthermore, security and auditing teams can visualize all the security crisps across all of the project's master branches in a single, unified dashboard, providing the ability to take action against any vulnerability found in the automated security tests that run in every code commit. And last, auditing events provide insight into operations executed in your GitLab instance, making managing roles and permissions across multiple projects easy to review and update. So as you can see, GitLab's single application builds the bridge to cloud-native success by implementing features and workflow across the entire development lifecycle by making it easy to automate, collaborate, integrate and visualize your entire application. Thanks for listening.