7 ways to speed up your build cycle

Few things have more potential for causing stress within software teams than a defective build cycle. Each of us remembers the first time in our careers when our code broke the build. For many of us, there’s still a sigh of relief at each step in the process when nothing blows up.

In a perfect world, where we’d all write flawless code with 100% test coverage, builds would be stressless, boring affairs. But even in the actual world, with technical debt, bugs, and dependency issues, there are plenty of ways to make build cycles faster and less painful.

The following is a list of high-impact ways that your team can speed up your build cycle which can have a dramatic impact on your overall velocity and effectiveness. Don’t worry, it doesn’t involve completely re-architecting your pipeline (good luck getting that project approved).

1. Have a work item plan

Make sure everyone on the team knows which tickets, stories, and issues are planned for the build in advance. This lets you avoid issues where something fails and no one is quite sure who changed the relevant piece of code.

2. Stick to the schedule

Agree upon a firm code complete cutoff time. This should usually be based on the timeline of the highest-priority tickets. If changes aren’t ready (including code review, testing, and QA), then they should automatically be pushed to the next build. 

Within the team, determine a clear consensus on which changes are the highest priority and which ones are less time-sensitive.

3. Use messaging for release status

Feed important release information into a shared messaging channel. This lets you track commits, code changes, tests, and build results automatically. Your messaging tools should make it easy to integrate status alerts from various services so that everyone on the team can hear about important updates quickly. 

Identify the highest-value information and send it directly to your team’s primary channel. If you create a channel specifically for alerts, you risk important messages getting lost as background noise.

4. Reporting tools can use messaging, too

Make sure that errors and test failures get surfaced as soon as they occur. There’s nothing worse than waiting until the end of an hour-long test run to find out that a test failed two minutes after starting. By integrating your reporting tools into your team’s messaging channel, you can make sure that failures are triaged and fixed as quickly as possible.

5. Share infrastructure status where it’s needed

Broadcast the health status of your build pipeline and cloud services. As more teams embrace distributed systems and microservices, there’s a lot more potential for key systems to fail silently. Make sure that it’s easy to check the status of all cloud environments. (Even better, have any changes get shared with your team automatically.)

6. Document your work and processes

Some of the biggest delays occur because a key piece of system knowledge exists solely in the head of one long-time employee—who happens to be out of the office at the worst possible time. 

Lots of teams document what should happen in the build cycle. But they don’t take the time to write down which steps should be taken if various errors occur. The added benefit of writing everything down is that it increases the confidence level of the whole team.

7. Trust and empowerment grow your team

Actively create a culture of trust and empowerment. A team in which every member feels comfortable saying that their code is ready to deploy—and even more so, feels confident triggering the actual deployment—is essential for moving quickly. 

It’s not uncommon for tasks such as deployment to be the domain solely of senior-level engineers. This is unfortunate because letting junior-level engineers handle deployments lets them gain comfort and familiarity with the deployment process. It also means that when things go wrong, they’ll become more comfortable responding to technical roadblocks instead of waiting for senior team members to tell them what to do.

Mattermost empowers teamwork and communication

Every team wants to build better software faster. But real-world limitations mean that teams are often stuck choosing between either quality or speed. 

For many organizations, there is high-value, low-hanging fruit in the form of simple workflow changes that can make teams more effective. This includes the creation of solid processes and communication patterns based on tools that reduce overall complexity.

This is why integrations and workflows are such an important part of Mattermost. Effective communication isn’t just about talking with one another. It’s also about making sure that the right information is delivered to the right people at the right time, automatically.

If you’re interested in learning more about how we work toward this goal every day at Mattermost, these resources are a good start:

• How DevOps Teams Use Mattermost
• The Manager’s Guide to Messaging for Dev Teams 
• The Mattermost Integrations Directory 
• How Galois Uses Mattermost to Coordinate Their Distributed IT Teams 

(Editor’s note: This post was written by James Timmins, software consultant and Python developer. If you have any feedback or questions about 7 ways to speed up your build cycle, please let us know.)