Case Study: How a FinTech Company Improves Code Review Process

June 30, 2020
#Case Study#Bitbucket
8 min

We’ve got pretty good with our Pull Request and Code Review process, but initially, our PRs were complex, not very well documented, and difficult to read. The Resolution Time Distribution graph shows how better we are getting at this, being able to merge PRs much quicker than before.

Pablo Reyes, VP Engineering at Strands

Strands is one of our customers that has been using Awesome Graphs for Bitbucket for a couple of years so far. Since 2004, Strands has been developing highly customizable digital money management software for top-tier financial institutions worldwide. Our team is happy to help them reach their goals and improve their development processes with the statistics visualizations we provide.

Pablo Reyes, VP Engineering at Strands, agreed to share how their team uses our solution and provided us with a picture of how they:

  • identified bottlenecks in code review
  • tracked if this process was improving with the changes they implemented
  • increased developers’ motivation watching the trends in individual performance.

Code review process improvement

In fact, they’ve got pretty good with their Code Review process so far. But initially, the PRs were complex, not very well documented, and difficult to read. The Resolution Time Distribution report shows how better they are getting at this, merging PRs much quicker than before. code review process improvement in Bitbucket

Since they do a lot of code reviews at Strands, it’s always nice to see who and what teams are making the best use of it. It’s encouraging for the team to see the progress with these reviews, and the Pull Requests reports give them the perfect overview of these improvements.

A couple of years ago, they started improving their methodology. For example, introduced the practice of approving PRs by at least three people. Moreover, they also encouraged developers to leave lots of comments and suggestions and not approve a PR until it’s good enough.

PRs are resolved faster now because they are done better, and the quality of suggested things improves all the time. As a result, it’s nice to see how senior developers make sure everything is done according to coding guidelines. Overview of how things are going and if it improves or not is presented in the Contributions report.

contributions report in Bitbucket

Coding trends

At Strands, managers don’t use Awesome Graphs to control the number of commits per developer, but they find it useful to look at the dynamics of the overall activity to capture the trends. For example, if there’s a significant drop, the developer is probably stuck at some difficult tasks or disturbed by various activities, helping other teams or communicating with customers.

Most things are caught soon in the day-to-day communication and work, but mid-term changes in the trend (either a decrease or increase) give them a hint of something they may need to look at. This has been visible when people change projects or teams.

The Developer’s Contributions graph gives a clear view of this kind of drops and rises, and it’s handy to compare two periods before and after certain changes were implemented.

developer contributions in Bitbucket

Any trend is a good point to discuss and find if there’re any bottlenecks or places to be improved with the processes in a team. Performance is a complex measure and depends on lots of different things, some quantitative and some qualitative, but the aggregation of code contributions (comments, pull requests, tasks solved, commits, etc) gives some good indicators on how a team is evolving with time.

Along with the others, the Contributors graph provides this kind of insight into the dynamics of code contributions by different teams.

code contributions by different teams

Try the best teams’ practices for your company

Awesome Graphs for Bitbucket has become a useful tool for Strands on their way of identifying where the problematic places are, and tracking if the implemented changes improve the situation or not. Besides, it appeared to be a handy instrument for regular monitoring.

Try Awesome Graphs for Bitbucket for free and check if it can help you as well.

Read more case studies to see how our customers benefit from using Awesome Graphs for Bitbucket in their work:

Project Development in Confluence Explained Simply

April 16, 2020
#How To#Confluence Tutorial#Confluence#Case Study#Project management
25 min

Maria Palagina from Tinkoff wrote this blog post and published it on a Russian collaborative blog about IT. Our team read it and just loved how Maria described the way she works with Confluence labels, templates, and macros, including the Page Properties macro. We also want to thank Maria for featuring our app. We translated this blog post into English to share it with our readers.

Hi everyone!

My name is Masha, and I work as a quality assurance engineer at the Tinkoff group of companies. QA work involves a lot of communication with different people from different teams, and I was also a manager and lecturer in educational programs, so my communication experience was as rich as possible. And at some point, I blew up: I realized that I couldn’t, absolutely couldn’t stand filling the hellish amounts of unreadable tables and documents anymore.

I’m sure that each of you pictured what I am talking about and is now covered with cold sweat:

  • lists of last names with no alphabetical order,
  • tables with hundreds of columns that have a broken layout,
  • tables with thousands of table rows, when you brush-burn you finger with mouse scrolling because you need to view the heading,
  • lots of pages with unnumbered instructions,
  • hundreds of letters we forward each other, I mean the letters with information we need to analyze and put in the same unreadable tables.

I had some time to calm down, and after that, I decided to write this blog post. I will tell you how to smoothly (and even easily) maintain non-technical documentation. I hope this blog post goes viral, and the level of pressure in teams that deal with developers will decrease at least a little, and people (myself included) will become a little happier.

The tools

Product documentation is often stored alongside code, and it’s OK. Non-technical documentation is usually stored just anywhere. Often people try to migrate information from different sources to Confluence, and we are no exception. So my blog post will be about this solution.

Confluence is a robust wiki platform. It allows you to work with data and display it the way you want: formatted text, tables, multiple diagrams. It is a very interesting and powerful tool, but if you don’t know the exact recipe, you will get another ton of unreadable documents! But I will show you how to cook it!


Practically all the magic in Confluence happens with the help of macros. There are a lot of macros, and you can combine them. They can be paid and free; I will show you different macros with the links to their documentation.

The macro interface is as simple as possible. To add a macro, click on the plus sign and select the desired item from the list.

If it is an independent macro, I mean, when it does not require the insertion of something else inside itself, it looks like a block.

If you need to insert something into the macro to make it work, it looks like a frame.

Moreover, you can put as many macros inside the frame as long as this pyramid of macros makes logical sense.

Each macro has a preview; it immediately shows whether you have configured the macro correctly.


In addition to macros, there is a handy tool that helps you prefill content; it is a template.

You can use templates when you create a page. Just click on the three dots next to the Create button and select the required template.

In this case, all content from this template will be added to the created page.

Anyone can create pages from templates; however, only users with permissions can create and edit these templates. You can add instructions to any template to describe how to manage the page.

The magic of tables

As a techie, I dearly love tables, and I can wrap almost any information inside a table (although it’s not always useful). The tables themselves are clean, structured, scalable, and magical!

But you can ruin even such a great thing as a table. Or you can successfully use it and make it even better. Now I will tell you about that.

Filtration (the paid macro)

You can turn any large table into a more readable and not so large table with the help of filtration. You can use the Table Filter macro for this purpose.

You need to insert a table inside this macro (it can be even the ugliest one, the most important thing is to insert the whole table). You can choose the columns to filter with the help of the dropdown filter, the text filter, the number filter, and the date filter.

Just imagine that all information about job candidates is in the table list. Of course, the list is not sorted because people come in for an interview not in alphabetical order. And you need to understand if you’ve already interviewed the job candidate before. All you need to do is to put this mess inside the Table Filter macro, add the text filter to search for last names, and voila, the information you are looking for is on your screen.

It is worth noting that the filtration of large tables can affect the system performance and page loading time. That is why putting the large table inside the filter is a temporary solution, it is better to have a workflow when people do not need to create large unreadable tables (you will find such an example at the end of this blog post).

Sorting (the paid macro)

Using the magic Table Filter macro, you can also number the rows and set the default sorting by any column. Or you can click any column of the table that is already in the Table Filter macro, and it will filter the table by this column.

For example, you have the same table with job candidates, and you need to check the number of job interviews you performed for a given month — sort by date and be happy.

Pivot table (the paid macro)

Now let’s move to a more interesting case. Imagine that your table is huge, and you need to calculate something with the help of this table. Of course, you can copy it to Excel, calculate what you need, and upload the data back to Confluence. Or you can use the Pivot Table macro and get the result that will be dynamically updated.

For example, you have a table with information about all employees: their locations and job titles. To find out how many people are in each city, you need to choose the row label (Location) and operation type (Count) in the Pivot Table macro.

Of course, you can group data by several criteria at once, you can read about all the features in the documentation.

Charts (the paid macro)

Like I said, not everyone loves tables as much as I do. Unfortunately, the majority of managers do not like them at all. But everyone loves vibrant color charts. The creators of Confluence, of course, knew about it (probably they also have bosses who love reports and charts). That is why you can use the magic Chart from Table macro. You need to insert the pivot table from the previous paragraph into this macro, and voila, your boring gray data is beautifully visualized.

Of course, this macro also has settings. You can find the link to the documentation of any macro in the edit mode of this macro.

Ease of aggregation

The information from the previous paragraphs probably was not news for you. But now you know how to use macros, and I can move on to a more interesting part of the article.


It’s terrible when people store information on one unstructured page or in a large table. And it’s even worse when parts of this information are not only unreadable but also scattered all over your Confluence. Fortunately, you can collect the scattered data in one place. To do this, use the labels (like tags everyone knows from social networks).

You can add as many labels as you need to any page. If you click on a label, you will be redirected to the aggregation page with the links to all information with this label, as well as with a set of related labels. The related labels are the labels you often find on the same page.

Page Properties (the free macro)

To structure information, you can add another great macro to the page that is Page Properties. You need to insert a two-column table into the macro; the first one lists your key, and the second will contain the value for each key. Moreover, you can hide the macro from the page to read the content without interruptions, but at the same time, the page will still have the necessary keys.

Pay attention to the ID. It is easy to set it to add different property groups to different pages (or even different property groups to one page).


You can create reports with the help of labels. For example, the Content Report Table Macro collects all pages with a specific set of labels.

But you can create a more interesting report with the help of the Page Properties Report Macro. It also collects all pages with a specific set of labels, but it not only displays a list of them but compiles a table (do you catch my drift with the beginning of the blog post?), where columns are the keys to the page properties.

You get a pivot table based on information from different sources. It’s nice that it has such handy functions as adaptive layout and sorting by any column. Also, you can configure this reporting table inside a macro.

When you configure your report, you can remove some columns, set the default state, or the number of displayed records. You can also set the page property ID to see only the information you need.

For example, you have a lot of pages with information about employees; these pages have a set of properties about each person: their level, location, dates they joined the team, and so on. These properties have the ID = employee_inf. There is also another set of properties on the same page that collects information about each person, as a part of the team: their roles, teams, and so on. These properties have the ID = team_inf. When creating the report, you can display only information about one ID or two at once depending on your needs.

The beauty of this approach is that everyone can collect the insightful table they need; this table will not duplicate data and will be updated automatically when the main page is updated. For example, a team lead doesn’t care when developers got a job, but the team lead needs information about what role each of them plays in the team. The team lead will create a report about the team. And the accountant doesn’t care who performs what role, but the job titles are relevant. The accountant will create a report on the job titles. In this case, the source of information will not be duplicated or transferred.

The final process


So, now we can beautifully structure and efficiently aggregate information in Confluence using macros. But in a perfect world, you need to make sure that new information is immediately structured and added to the aggregation mechanisms we’ve already used.

In this case, a bundle of macros and templates can help you. To make people create new pages in the required format, you can use the Create from Template Macro; it adds a button to the page. When you click it, you create a new page from the required template. This is how you make people immediately work the way you need.

In the template from which you are creating a page, you need to add labels, the Page Properties macro, and a table with required properties in advance. I also recommend adding instructions on what values ​​users should fill the page with and describe the property values.

In this case, the final process looks like this:

  1. You create a template for information of a specific type.
  2. You add labels and page properties to the macro of this template.
  3. In any Confluence space you choose, you create a parent page with a button that creates a child page from the template when you click it.
  4. You grant access to the parent page for users who are supposed to generate the required information (according to the desired template, by clicking the button).
  5. You draw up a report on the page properties with the help of the labels you specified in the template.
  6. You are enjoying the moment. Now you have the required information presented in a user-friendly way.


As a quality engineer, I can say without hesitation that there is nothing perfect in the world. Even the divine tables are not perfect. And the above-described process has pitfalls.

  • If you decide to change the names or a set of page properties, you will have to update all objects you created, so that their data is correctly pulled into the summary report. It is sad, but, on the other hand, it makes you think through the architecture of your set of information in detail, and it is an exciting task.
  • You will have to write a decent amount of instructions on how to fill out tables and use labels. But, on the other hand, you can share this blog post with all the people involved.

How to store non-technical documentation

You can organize the storage of almost any information with the help of the above-described process. The beauty of this approach is that it is universal; when users get used to it, they stop making a mess. Also, the capability to collect various statistics on the fly and draw beautiful diagrams based on it is a significant (but not a free) plus score.

I’ll show you how we maintain information about our team.

We decided to create an employee card for every team member. This means that we have a template that every new person uses to create this card and maintain all personal information in it.

As you can see, we have a detailed table of properties and instructions on how to maintain this page. Employees add some labels themselves using the instructions; the template contains only the main ones:

  • the employee-card label
  • the direction-involve label
  • the team-qa label

As a result, when all users created cards for themselves, we have a complete table with employee information. We can use this information at various points. Resource managers can draw up general tables for themselves, and team leads can create team tables adding a team label to the selection.

You can see different reports using labels; for example, if you use the qa-upgrade-plan label, you will see all QA development tasks. At the same time, each person maintains critical information and development plan in their employee cards, creating an embedded page from the template of development plans.


Maintain any documentation and do not let it blur your reputation and drive your users mad!

I do hope that my blog post will be useful for you, and there will be order in documentation all over the world.

How to Perform Code Review and Track Team Activity in Bitbucket

August 8, 2019
#How To#Bitbucket#Case Study
6 min

Resolution Time Distribution Reports have helped a lot during the development of a high priority module to increase the reviewers, review frequency and also track team activity in Bitbucket.

Eduard Pal, Innoface

Innoface GmbH, one of our customers, is one of the leading providers of interfaces between PDM and ERP systems worldwide. Its applications help ensure a direct and reliable flow of information between engineering and logistics. They also offer additional products and services in order to facilitate seamless integration of the involved systems.

Innoface product development team uses Awesome Graphs for Bitbucket mostly for making data-driven management decisions. They find it very useful to:

  • track the activity of each developer and a team in general;
  • check if code review goes according to the plans;
  • predict time to resolve pull requests.

Let’s see how Innoface benefits from using Awesome Graphs for Bitbucket.

Tracking team activity in Bitbucket

Activity graph helps Innoface have a high-level overview of the total number of commits and contributors in a specific period, for example, a week. It also provides an opportunity to track the number of open pull requests from all the contributors and the repositories.

Using this graph, the manager can assess the activeness of a contributor. This gives the manager an idea of whether an employee is following the company’s development policy or not as well.

tracking team activity in Bitbucket

Based on the number of open pull requests, the manager in Innoface can actually plan time to review the code and merge them. This graph also gives an opportunity to process the pull requests from the contributors that are working on the high-priority projects.

Analyzing code review practices

Innoface management finds Resolution Time Report very helpful when it comes to tracking the frequency of processing the pull requests.

analyze code review in Bitbcuket

The manager uses this report in order to see the frequency with which the reviewers are processing the pull requests. Based on the data that this report provides, it’s easier to make a reasonable decision and to assign either more reviewers or increase the frequency of the reviewers, especially for the high-priority projects.

Predicting pull requests resolution time

Resolution Time Distribution report helps Innoface estimate resolution time for future pull requests to make more accurate release dates planning.

pull request resolution time in Bitbucket

The manager of a product team uses this report in addition to the Resolution Time Report in order to estimate the resolution time for future pull requests.


Awesome Graphs greatly enriches the Bitbucket user experience for Innoface. With its help, it becomes much easier to make decisions based on data and keep an eye on how efficient their development practices are.

Read more case studies to see how our customers benefit from using Awesome Graphs for Bitbucket in their work:

Start a free trial of Awesome Graphs

Case Study: How THN Uses Handy Macros for Confluence for the Equipment Check

February 5, 2019
#Project management#How To#Confluence#Case Study
7 min

The primary benefit of this app for us is the better insight and much quicker and easier maintaining of our equipment lists.

We would certainly recommend this app, we would highlight the improved insights and time savings that it gives.

Alex Scheele

THN is a wholesale company with more than 75 years of experience in storing and delivering technical products. THN is at the forefront with the latest developments. The company has set up an entirely new IT infrastructure in 2018. THN actively uses Atlassian Confluence for team collaboration. Confluence helps them bring equipment lists and all information about maintenance of measuring instrument and assets into one place.

THN’s workflow in Confluence

When the company purchases a new measuring instrument, a facilities manager inspects it and adds it to the list of measuring instrument and equipment. Then he enters data in all of the following relevant fields: internal code, brand, model, inspection date, inspection interval, and expiry date.

When some of the items has reached its expiry date, the facilities manager inspects and tests the item. If he approves the equipment, he updates the information about inspection and expiration dates in the list.

THN maintains at least 5 lists of measuring instrument and equipment with more than 30 entries in each list.

The key issue

Although Confluence helps to collaborate effectively, the maintenance of these lists was the most time-consuming task for all users. The users had no opportunity to highlight the expiry dates of listed equipment. They had to look through the lists regularly not to miss any inspection date.

The CEO and the management team wanted to quickly access all the information about inspections. They wanted to get a quick insight into the inspections in one click to check their timely completion.

1. table without macros

When you look at this list, nothing catches your eyes. You need to look through all the dates to find the expired ones.

As a workaround, the company used the user macro that displayed a status of an inspection with the help of green or red boxes depending on the due date. The user macro visualized the lists, but it was difficult to use. After the last inspection, a user had to enter a new expiry date multiple times separately. This solution required a lot of time and caused a risk to make a mistake.

Setting reminders with Handy Reminder

The Handy Macros for Confluence app includes the useful Handy Reminder macro. The macro allows a user to add a reminder to a Confluence page, set a date, time, and recipients. When equipment reaches its expiry date, the recipients get an email notification. The Handy Reminder macro also can display the set date next to the reminder icon. Dates change their color to orange in seven days before the expiry date and turn red when the due date is coming.

With the help of this feature the THN team can now create easy-to-use instrument lists. Instead of using multiple date fields and the user macro all members of the team can manage only the Handy Reminder macro.

2. table with handy reminder

Now the THN team can set a new expiry date and a reminder with a few clicks. They can do this on the fly in the page view mode. A user chooses a date with the help of the date picker and the reminder becomes enabled automatically.

3. changing date in handy reminder

All members of the team have access to the lists. The expiry dates are well visualized and easy-to-change. The workflow is simple and transparent.

Challenges and benefits

The Handy Macros for Confluence app allows the customer to save time and avoid mistakes when maintaining lists of:

  • measuring equipment
  • power tools
  • electrical appliances such as air conditioners
  • insurance valuations of assets

The management team now has a bird’s-eye view of the inspection process.

The Handy Reminder macro provides THN with a neat solution for their challenge with the items that have expiry dates the team needs to check and update accordingly. 

We are looking forward to further collaboration with THN in the future. We also continue the development of the app and plan to deliver new useful features to boost the existing Confluence capabilities with the help of the Handy Macros for Confluence app.

Case Study: How BMW AG Uses Talk for Atlassian Confluence

October 16, 2018
#Case Study#Collaboration
6 min

BMW Group relies heavily on enterprise-ready, robust and mature software to fulfill highest quality standards. Creating comprehensive technical documentation for our worldwide retailer organisation is a very important part to support all business processes aiming for an extraordinary customer experience.

Adding Talk to our Confluence instance is a giant step forward in achieving a smooth and frictionless review within the authoring process.

Michael Merwald

BMW AG, our customer, is one of the world’s leading manufacturers of automobiles and motorcycles (BMW, MINI and Rolls-Royce brands). This global company operates 30 production and assembly facilities in 14 countries worldwide. Being one of the oldest carmakers in the industry, BMW AG manufactures sophisticated vehicles and sets trends in production technology.

Integrated Service Process Initiative (ISPI Next) is a multi-department project of BMW AG that unites more than 300 employees. Development of all service deliverables for the worldwide BMW Group retail organisation and third parties, e.g. hardware, software, processes, support, training and documentation is the main objective of this project.

The ISPI Next team uses Atlassian Confluence to create, distribute, upgrade, and review all corresponding technical documentation. The team of the project decided to power up Confluence with the Talk – Advanced Inline Comments app to improve collaboration between authors and reviewers of the content they create.

Collaborative authoring

The authoring community of the project can easily access the comments created with the help of the Talk app while editing and revising their text. All discussions are available both in the view and edit modes that helps the team facilitate their work on the content.

discussion in Confluence in page edit mode


The capability to work with comments during collaborative text editing allows them to point out relevant documentation parts among each other to edit or extend those towards a comprehensive body of knowledge.

Ensuring high quality documentation

During creation of their technical documentation, the ISPI Next team relies on peer review to enhance documentation quality upfront. Talk enables them to do so including their specific requirements meeting the BMW Group Quality Goals.

They can prioritize comments to help their colleagues tackle the talks by priority and focus on what matters for the team at the moment.

high priority discussion in Confluence


This useful feature helps them improve their review process and structure their work with Confluence content. Now all the team members can quickly look through all the talks to find the ones that require immediate attention.


To support the release cycles of ISPI Next, the team uses the Talk Report to manage the scope of review comments and get a detailed report of which improvements found their way into documentation.

The project manager and also teams can easily get an overview of all the comments within a space to clearly identify what is done and what needs action at the moment.

overview of all the comments within a Confluence space

This way the Talk report helps the document responsible people locate the talks without mentions and make sure that the comments assigned to their team members will be resolved as soon as possible.

Challenges and benefits

The Talk – Advanced Inline Comments app makes reviewing technical documentation a breeze for the ISPI Next team of BMW AG. This solution allows them to easily:

  • Add and review comments both while viewing and editing the content;
  • Prioritize discussions to draw their colleagues’ attention to the urgent issues;
  • View all the list of all comments (open and resolved) within a space.

This solution helps the ISPI Next team and other Talk users save time and effort while working on their content in Confluence.

Case Study: How to Evaluate Code Quality in Bitbucket

March 21, 2018
#Analytics#How To#Bitbucket#Case Study
7 min

This plugin helps us in Code Frequency to evaluate code quality and project history. Contributors evaluate the code committed by each person in a sprint and we use the Activity stream to show all commits and pull requests of the selected time span as the activity stream with links to associated Jira issues, subtasks, and backlogs.

Hemanth Dharavath, Apptium

Apptium Technologies, our customer, is a technology and management consulting company that helps global broadband, wireline, and wireless communications service providers boost their productivity. This company has offices in the USA, Canada, and India.

The team of Apptium Technologies actively uses Atlassian Bitbucket for team collaboration. This way they can build and ship software to their clients that use Apptium application as Platform as a service (PAAS). They decided to extend the Bitbucket Server functionality by installing our Awesome Graphs app.

In fact, our customer has around 25 projects going parallel. Each project has its own dev, QA, production environments with around 15 repositories. All team members use the Awesome Graphs app to track and monitor their projects and repositories with visualized statistics.

Let’s see what features and capabilities of this app the Apptium team uses most.

Activity tracking and reporting

As an Agile software development team, Apptium wants to track down issues and daily updates of the tasks assigned in their sprints. For instance, to achieve this goal, they use the Activity graph. It shows the existing commits and pull requests through the selected time span at the project level, featuring activity in all project repositories.

activity tracking and reporting in Bitbucket

Moreover, our client can also check the activity stream with the links to the associated Jira issues, sub-tasks, and backlogs. This way, they can easily track daily updates for their current Jira tasks.

Contribution analysis

The Contributors graph helps the Apptium team to evaluate the code committed by each person in a sprint. They can compare the input from different team members with a help of a summary graph of the contributions made by all developers. In addition, they evaluate the number of commits and lines of code added and deleted by each developer.

contributions made by developers in Bitbucket

Using this graph, the Apptium team can evaluate the team’s performance and analyze the critical points throughout the year.

Getting insights into project history

The Code Frequency graph allows Apptium to evaluate the project history and code quality. The team members can watch the dynamics of their projects in terms of lines of code.

evaluate code quality in Bitbucket

As a result, the Apptium team can have a birds-eye view of the whole project from its start to the current week in one graph.

Commit frequency evaluation

Apptium Technologies also uses the Commits graph to pull out the report on commits made to repositories every week (each bar represents one week). So they can compare their estimates with the real work done and plan their work on the projects ahead.

commit frequency in Bitbucket

This useful graph provides our client with an overview of their team activity.

Challenges and benefits

The Awesome Graphs app allowed the customer to get the detailed visualized statistics of their team performance and address the following challenges:

  • analyze the critical points along the year
  • track activity and progress of the team
  • watch their projects evolve
  • capture trends and identify bottlenecks

Apptium Technologies now can rapidly evaluate the performance of their development, QA, and production teams. The insights they receive using our handy tool definitely help them deliver the best service to their customers all over the world.

Read more case studies to see how our customers benefit from using Awesome Graphs for Bitbucket in their work:

Try Awesome Graphs for free