As Head of Development for a small team building both mainframe and Linux-based software, I’ve had a front-row seat to a significant shift in how we work.

Over the past few years, we’ve moved from largely mainframe-based source code management tools to Git. Like any meaningful change, it came with a degree of hesitation. But looking back, the impact on our collaboration, consistency, and overall effectiveness has been transformative.

Collaboration Through Transparency

Using Git provides an amazing level of visibility – team wide. Every change is recorded, every commit has context, and every pipeline run is available for review. This creates a shared, transparent view of the system that anyone in the team can access.

We saw the value of this very clearly during a recent project. While completing final testing, we identified a small bug. A developer fixed it, ran the pipeline, and generated a new package before finishing for the day. Shortly afterwards, we discovered that the package still contained the issue.

In the past, this would likely have led to a delay while we waited for that developer to return. Instead, we were able to open GitHub, locate the exact commit that implemented the fix, and trace it through our GitHub Actions pipeline. We could see what had run, what had failed, and where the process had gone wrong.

Even without deep knowledge of that specific area of the codebase, the team had enough information to understand the issue. We corrected the failing step, rebuilt the package, and completed the release the same day.

That confidence comes directly from transparency. We could see what changed, when it changed, and how it moved through our delivery pipeline, and were no longer dependent on a single individual.

A Shift in Mindset

Adopting Git sparked a shift in how we think about ownership and collaboration. There can be a natural tendency in software teams to associate parts of a system with individual developers. In the past, it would have been common to say, “that’s their code, let’s wait for them.” With Git, that way of working becomes less necessary.

Instead, we’ve been encouraging a mindset of shared ownership. The expectation is not that everyone knows everything, but that everyone is empowered to explore, understand, and contribute. Git makes that possible by exposing the full history of the codebase, supported by commit messages, documentation, and pipeline results.

This shift requires good development practices, well-maintained repositories, and clear documentation. It also requires trust—both in the tools and in each other. But over time, it leads to a more resilient, collaborative, and productive team.

Faster Support and Better Outcomes for Customers

The benefits of this approach extend beyond development and into how we support our customers. When a client raises an issue, the team member working with them can now immediately access the relevant code in GitHub and begin investigating. They can review the latest version, understand recent changes, and start investigating without needing to wait for a specific person to become available.

Previously, even if the code was technically accessible, there was often uncertainty about whether it was the same version the customer was running. That uncertainty created hesitation and, in turn, delays. Now, the clarity provided by Git allows us to act more quickly and with greater confidence. That responsiveness makes a real difference to our customers’ experience.

Improved Visibility and Knowledge Retention

Another important benefit has been the way Git supports knowledge sharing and long-term sustainability. Because all our code, configuration, and documentation are centrally accessible, knowledge is no longer tied to specific individuals or environments. New team members can explore repositories, review commit histories, and understand how systems have evolved over time. This significantly accelerates onboarding and reduces reliance on tribal knowledge or subject matter experts.

From a management perspective, this visibility is equally valuable. It provides a clear view of ongoing work through active branches, highlights how changes are progressing, and makes it easier to identify where standards need to be defined or improved.

It also enables continuous refinement of our development practices. We’ve been able to introduce and evolve standards around branch naming, documentation, and pipeline reuse, as well as implement organisation-level controls such as branch protection and shared configuration. All of this contributes to a more consistent and maintainable codebase.

Multi-Platform Consistency

Historically, our mainframe and Linux development practices were shaped by the tools we used. They naturally encouraged different workflows and different levels of visibility.

Today, all our source code, configuration, and much of our documentation lives in GitHub. By moving the mainframe code into Git, alongside the Linux code, we’ve created a much more unified development experience. Regardless of whether someone is working on mainframe or Linux-based components, they interact with the same tools and the same processes.

This has reduced fragmentation within the team and lowered the barrier to entry when contributing across different parts of the system. It also makes it much easier for new team members to get up to speed, because there is only one way to manage and interact with source, config and documentation.

The PopUp Adoption Approach

Our move to Git has been successful not just because of the technology, but because of how we approached the transition. We focused on establishing clear development standards and maintaining well-structured repositories so that the benefits of visibility could be realised in practice. We invested in documentation to ensure that others could understand and navigate the codebase. We encouraged shared ownership and gradual adoption, allowing the team to build confidence over time rather than forcing a sudden, disruptive change.

We treated this as an ongoing journey rather than a one-off implementation – as our use of Git has matured, so too have our practices. We continue to refine how we work, learning from experience and adapting as our needs evolve.

A Clear View Ahead

By making our code, processes, and practices transparent, we’ve enabled better collaboration, faster problem-solving, and a more resilient team.

Adopting Git has given us a strong foundation, but the real value comes from how we build on it. And it is a journey that many organisations are on, including those working across a mix of mainframe and distributed platforms. Our experience has shown that it’s not only achievable, but highly beneficial when approached in the right way. If we can help you in any way with your transformation (here’s some recent advice), please get in touch.