Case Study

Driving Efficiency: The Story of Floki Technologies' Impressive 37% Cycle Time Improvement

Read case study

In the competitive realm of procurement technology, Floki Technologies has distinguished itself as a leading provider of technology aimed at revolutionizing the purchasing process for bars and restaurants in Brazil. Floki offers a comprehensive platform that empowers businesses to streamline their procurement operations, optimize vendor management, and drive cost savings.

Recognizing the critical role of developer productivity in delivering exceptional solutions and gaining a competitive edge, Floki’s CTO Leonardo Pinheiro Ferrari, and his team partnered with Hivel. With a strong commitment to revolutionizing their internal processes, Floki’s engineering teams used insights from Hivel to ship features of impeccable quality at a rapid frequency.

  • Floki faced challenges with missed release deadlines, prompting their engineering leaders to seek data-driven solutions.
  • They focused on improving speed, quality, and throughput in their development process.
  • Encouraging developers to code in smaller chunks reduced coding time by 57% and accelerated code completion.
  • Smaller code pieces streamlined reviews, leading to a 29% reduction in review time and faster pull request progress.
  • These improvements resulted in an impressive 37% reduction in cycle time within 90 days, achieving Floki's speed and throughput goals.
  • Deployment frequency increased by 29%, while hotfix occurrences significantly decreased.
  • Through their partnership with Hivel, Floki identified and eliminated bottlenecks, enabling faster roadmap delivery with improved quality.

Reduced cycle time by 37% by reducing coding and review time

Before Hivel After Hivel
Missed release deadlines Reduced coding time by 57%
By encouraging developers to code in smaller chunks, they sped up the coding process.
PRs were stuck in the review stage for too long. Reduced review time by 29%
The smaller pieces of code helped in speeding up the time taken to review, and PRs moved faster through the pipeline.
Slow cycle time that was affecting value delivered to the end user. Reduced cycle time by 37% in 90 days
Achieved their goal of improved speed and throughput by identifying and removing the blockers slowing down the development process
Low throughput - what was being planned in sprint-planning was not able to be executed Increased deployment frequency by 29%
by optimizing the development pipeline
Too many production bugs Reduced hotfixes
Hotfixes were reduced to almost zero, and we hope it stays that way

Firstly, the reduction of coding time by 57% is a remarkable achievement. Encouraging developers to code in smaller chunks enabled them to focus on specific tasks, resulting in increased productivity and faster code completion. By breaking down complex coding tasks into manageable pieces, developers can work more efficiently, leading to reduced overall coding time.

Secondly, the 29% reduction in review time is equally significant. The smaller code pieces facilitated faster and more streamlined code reviews. With reduced code complexity, the reviewing process became more efficient, allowing for quicker identification and resolution of any issues or bugs. This accelerated review process ensured that pull requests (PRs) moved swiftly through the pipeline, minimizing delays and bottlenecks.

Ultimately, the combined impact of these improvements led to substantial results. Floki successfully achieved their goal of reducing cycle time by 37% in just 90 days. This significant reduction in cycle time demonstrates the effectiveness of their approach in identifying and eliminating obstacles that impeded the development process. Additionally, the increased deployment frequency by 29% showcases the enhanced speed and throughput achieved by optimizing the development pipeline. In other words, they delivered their roadmap ~30% faster with the same resources while improving quality.

Why did they need data from Hivel to solve this problem?


Their engineering team noticed that release deadlines were being missed. Not wanting to lose their competitive edge, their CTO, Leo, wanted to see data to be able to plug the leaks and help their developers release better quality and more features faster.

How did they solve this problem with Hivel?

This problem could only be solved if the engineering leadership had better visibility into reasons that hurt the speed and volume of releases.

Defined Objectives:

  • Find an optimal pace of deployment frequency to deliver good code quality.
  • Find the culprit behind the slow cycle time


  1. Gain visibility into current metrics
  2. Identify the bottlenecks slowing down cycle times and leading to missed deadline.
  3. Taking steps to Improve the Speed and Quality of Features released at the same time.
  4. Reduce the Change Failure Rate and find an optimal deployment frequency without hurting the code quality.

Some Investigations

The engineering team used Hivel to investigate these questions and aid their decisions using data.

  1. Why is coding and reviewing PRs taking quite long?
  2. Why is deployment frequency low?
  3. Why has there been an increase in the change failure rate?

Cycle Time Improvement

What screens revealed data to support their investigations?

  • Cockpit screen
  • Process screen
  • PR review screen
  • Coding screen


Leo, the CTO of Floki, identified the largest contributors to cycle time. Then, he with his team did a deep dive into data which revealed that the developers were coding in large chunks, taking them longer to release features. This meant large-sized PRs weren’t able to be reviewed quickly and pushed to production. This was resulting in both a low deployment frequency and cycle time.


The engineering team integrated their version control (Git) with Hivel to understand the leaks in the process.

They used Process, Pull Request, and Coding screens to track metrics such as:

  • Deployment frequency
  • Change failure rate
  • No. of PRs reviewed
  • No. of unreviewed PRs
  • Time taken to review PRs
  • Time taken to merge PRs to master

Is a high coding time a good or bad sign of software feature release efficiency?

Lengthy coding durations often indicate inefficiencies in the development process and can lead to delays in delivering software solutions to clients or end-users. Excessive coding time can be indicative of various issues, such as poor code organization, lack of modularization, or inefficient development practices. These factors can negatively impact productivity, increase the chances of introducing errors or bugs, and hinder the ability to respond quickly to changing requirements or market demands.

On the other hand, it is important to note that coding time alone should not be the sole metric for evaluating software development delivery. Factors such as code quality, maintainability, and adherence to requirements and industry standards also play vital roles in the overall success of software projects. Striking a balance between efficient coding practices and ensuring high-quality code is crucial for successful software development delivery.

How to address missed feature release deadlines?

If your team is missing feature release deadlines, it is crucial to follow two key steps to address it.

  1. First, assess the reasons for the delay and prioritize the remaining tasks based on their importance and impact. Identify critical dependencies and bottlenecks that require immediate attention.
  2. Second, take decisive corrective actions such as realigning the project timeline, adjusting resource allocation, and improving communication within the team. Implement efficient task tracking and progress monitoring mechanisms while keeping stakeholders updated to manage expectations effectively. By undertaking these steps, organizations can mitigate the impact of missed deadlines and ensure the successful and timely delivery of subsequent features.

Org-wide changes

Using data from Hivel, the engineering leadership was able to represent the problem and validate their decision to change coding and review processes to improve cycle time and deployment frequency. They were able to provide direction to the engineering managers on how to manage sprints better. This helped them ship features faster while maintaining a high quality of releases.

Productivity Insights and Learnings

Address issues of missed release deadlines as soon as they happen to avoid impacting the end-user
Be vigilant of bottlenecks in your development process that slow down your developers