Software development rarely happens in isolation, especially not in our projects at PROTOS. We work in cross-functional teams, distributed and often working on the same code in parallel. This means we need tools that support teamwork, security, and speed.

One of the platforms we use particularly frequently is GitLab. But GitLab is not an end in itself for us—we also work with Azure DevOps or GitHub Enterprise, depending on the project and requirements. So the question is never, “Do we use GitLab?” but rather, “When is GitLab the best choice and why?”

Practical example from our projects

In a recent customer project, the decision was between Azure DevOps and GitLab. The advantage of Azure DevOps was that the corporate licenses were already in place. It also integrated seamlessly into the Microsoft landscape. On the other hand, GitLab offered the ability to build CI/CD pipelines at high speed, including security checks, container builds, and Kubernetes deployments.

Together with the customer, we decided on GitLab because pipeline runtimes were crucial for time-to-market. In addition, operation in a private cloud was required, which was easily implemented with GitLab Self-Managed. Reusable pipeline templates also enabled us to standardize and sustainably accelerate development processes.

Technical insights: What GitLab brings us in our daily work

The practical example described above shows why we choose GitLab for certain projects. It becomes even more interesting when you take a closer look at how we actually use the platform and what technical advantages this brings.

When developing a REST API, our pipelines run through several stages:

• Build & Test: Unit and integration tests, static code analysis.
• Security: Container scanning and dependency checks.
• Deploy: Automated rollout in Kubernetes (staging, later production).

Through targeted caching (e.g., dependencies), we were able to reduce runtimes by 40%. We also use dynamic pipeline rules so that no complete build runs for pure documentation changes. This saves costs and speeds up feedback cycles. It is precisely this combination of automation, security, and efficiency that is crucial for us in our day-to-day project work.

What sets GitLab apart for us time and again is that it combines the entire software development cycle in one tool – from source code management with integration to ticket systems, CI/CD, security functions, and monitoring. This allows all teams involved – from planning, development, IT operations, and security to business stakeholders – to collaborate on a common platform. GitLab thus enables end-to-end collaboration in the areas of planning, development, security, deployment, and monitoring.

And when we don’t use GitLab

Just as we consciously choose GitLab for some projects, there are also situations where another platform is the better choice. The decisive factor is not which tool promises the most features, but which one fits the customer’s existing processes, framework conditions, and objectives. Especially in complex IT landscapes with established structures, it is important to take the existing infrastructure into account and not to create an unnecessary parallel world.

A clear example of this are companies that have established Azure DevOps across their entire group. There, processes, permissions, and integrations are deeply embedded in the Microsoft environment, so switching to GitLab would rarely bring additional benefits and would often mean unnecessary effort. It is always our job at PROTOS to make concrete considerations that advance the project.

We carefully examine which platform offers the greatest added value for each project. This could be GitLab, but it could just as easily be another solution if the circumstances warrant it. Three aspects are particularly decisive for us in this regard:

• Existing infrastructure: Which tools and processes are already deeply entrenched and should not be artificially duplicated?

• Ecosystem and integrations: Where does choosing a particular platform create synergy effects that bring real benefits to the customer?

• Operational and compliance requirements: Which specifications regarding hosting, security, or regulatory frameworks must be taken into account?

This way, we ensure that the focus is not on the tool, but on the solution that makes the most sense for the customer in the long term.

Tips for using GitLab in everyday DevOps work

Now that we have shown when and why we use GitLab in projects, we would like to turn our attention to practical applications. After all, the true strength of GitLab is not only evident in the strategic decision to use the platform, but above all in its daily use. This is where experience, best practices, and the occasional pitfall quickly accumulate. Below, we share tips from our everyday project work that will help you use GitLab more efficiently, securely, and sustainably.

Common mistakes – and how to avoid them smartly

Of course, things can sometimes go wrong when working with GitLab. Here are a few common pitfalls from everyday project work—and how you can easily avoid them:

Secret access data accidentally committed
A classic scenario: passwords or API tokens end up in the repository. Removing such data from the Git history is tedious and prone to errors.
Our tip: Encrypt secrets in your own files with sops or store them in a vault and activate a secret scanner.

Working directly in the main-branch
Changes made directly in the main branch make collaboration more difficult, increase the risk of merge conflicts, and can lead to unstable deployments.
Our tip: Use feature branches and merge requests consistently. Protect the main-branch via the repository settings.

Slow pipelines due to lack of caching
Without targeted caching, builds and tests take significantly longer than necessary.
Our tip: Use cache:-blocks for frequently used dependencies such as node_modules, Composer, or Docker layers.

Recurring jobs copied over and over again
This makes CI/CD configurations confusing and difficult to maintain.
Our tip: Store recurring jobs (e.g., tests, linting, security checks) in templates and integrate them with include:.

Unnecessary jobs performed for minor changes
If linting or building still runs when text or documentation changes are made, this is an unnecessary consumption of resources.
Our tip: With rules: or only:definitions, certain jobs can be skipped in a targeted manner – saving time, money, and energy.

Efficient GitLab hacks for everyday project work

Here are a few best practices that will help you make your pipelines not only faster but also more sustainable:

Use CI/CD caching in a targeted way
cache:-blocks can be used to reuse node_modules, Composer dependencies, or Docker layers, for example, which often reduces pipeline runtimes by 30–70%.

Introduce templates for recurring jobs
Whether tests, code scans, or security checks – centrally maintained .yml-templates make your CI/CD configurations leaner, clearer, and easier to maintain. Integration via include: saves time and reduces errors.

Skip jobs for non-critical changes
With rules: or only:-criteria, certain jobs (e.g., linting for documentation changes) can be specifically deactivated – this conserves resources and reduces waiting times.

Only build what changes
Intelligent build jobs detect whether anything has changed in the relevant part of the code. They use changes:-specifications for this purpose, which is particularly useful for mono repositories.

Want more tips on GitLab? Download the GitLab Cheat Sheet for free here.

Conclusion: Strategic decision & practice

For us, choosing GitLab is never an end in itself, but rather the result of a conscious decision made in the context of customer requirements. Strategically, GitLab is particularly convincing where speed, flexible integrations, and private operating models are required. Operationally, the platform then unfolds its full strength: an integrated toolset for the entire development cycle – from planning and CI/CD to security and monitoring.

It is precisely this interaction that provides added value: while GitLab addresses time-to-market and compliance requirements at a strategic level, it enables efficient, secure, and sustainable development processes in everyday use. With targeted caching, dynamic rules, or reusable templates, pipelines can be made leaner and faster – and it is precisely this experience that we are happy to pass on in the form of our tips.

Ultimately, it’s not about presenting GitLab as the “better” tool across the board, but about getting the most out of every project – by choosing the right platform and fine-tuning it for practical use on a daily basis.

👨‍💻 Would you like to learn more about how we at PROTOS use GitLab to advance customer projects? Or are you looking for an environment where your ideas are not only heard but also implemented? Then take a look at our careers page. We look forward to hearing from you!

Do you have questions about our approach to projects, or would you like to modernize your own cloud infrastructure and DevOps processes?

Get in contact with our cloud expert Robert Hackenfort.

Get a free initial consultation