Forem: Emre Dundar

Optimizing Team Performance in Software Development

Emre Dundar — Tue, 14 Feb 2023 07:42:59 +0000

Optimizing team performance in software development requires a holistic approach that addresses both technical and cultural aspects of the development process.

In today’s fast-paced digital landscape, software development organizations are under constant pressure to deliver high-quality products in a timely manner. To meet this challenge, organizations need to identify and eliminate inefficiencies in their software development processes. This is where the Oobeya Team Health Module comes in, providing a comprehensive solution to optimize team performance in software development.

The Oobeya Team Health Module is comprised of two main components: Team Symptoms and Team Scorecard. These components work together to help organizations improve team well-being, performance, and productivity.

Team Symptoms: Detecting and Addressing Problems in the Development Process

The Oobeya Symptoms module is a powerful tool for identifying and resolving problems in software development and delivery processes. The Oobeya Symptoms module collects and analyzes data from various sources to automatically detect recurring issues such as anti-patterns, bad practices, and bottlenecks that may be hindering team performance. Upon identifying these issues, the module alerts teams to potential problems and provides recommendations and solutions to resolve them. This allows teams to take proactive measures to improve their processes and avoid obstacles that could impact their performance and health.

Available Symptoms (Coming More Soon)

The Oobeya Symptoms module currently includes the following symptoms:

Recurring high rework rate
Recurring high cognitive load
High weekend activity
High technical debt on Sonarqube
High vulnerabilities on Sonarqube
High code quality bugs on Sonarqube
Unreviewed Pull Requests
Lightning Pull Requests
Oversize Pull Requests

See the Oobeya Symptoms Catalog here.

Team Scorecard: A Comprehensive View of Team Metrics and Progress

The Team Scorecard provides teams with an all-encompassing view of their metrics and progress. The Scorecard automatically fetches data from integrations, eliminating the need for manual work and enabling teams to maintain standards across all their tools. The Scorecard consists of multiple team-based metrics, which come from different data sources such as GitHub, GitLab, Azure DevOps, Bitbucket, Jira, Jenkins, Sonar, Veracode, New Relic, DataDog, Dynatrace, and more. The historical data and team-based summaries provided by the Scorecard give teams deep visibility into their progress, bottlenecks, and areas for improvement, enabling them to make data-driven decisions and track the overall health of their teams.

Optimizing Team Performance in Software Development

Optimizing team performance in software development requires a comprehensive approach that addresses both technical and cultural aspects of the development process. Here are some strategies to help optimize team performance:

1. Clear Communication: Ensure that team members have a clear understanding of their roles, responsibilities, and expectations. Encourage open communication channels and foster an environment where team members can freely share ideas, concerns, and feedback.
2. Process Optimization: Evaluate and streamline development processes to eliminate bottlenecks and inefficiencies. Encourage teams to continuously improve processes through regular retrospectives and process improvement initiatives.
3. Collaboration Tools: Utilize collaboration tools such as code review, version control systems, and project management software to increase transparency, efficiency, and accountability.
4. Agile Methodology: Adopt an agile methodology such as Scrum or Kanban to better manage work and continuously improve.
5. Team Metrics: Track and measure team progress using metrics such as cycle time, code review, DORA metrics, and code quality metrics. Use these metrics to identify areas for improvement and track progress over time.
6. Continuous Learning: Encourage continuous learning through training, mentorship programs, and skill-building activities. This helps team members stay up-to-date on the latest technologies and best practices.
7. Employee Engagement: Foster a positive work environment that values employee engagement and well-being. Regularly check in with team members to understand their needs, and provide support to help them achieve their personal and professional goals.
8. Data-Driven Insights: Utilize data-driven insights to make informed decisions and track progress. Tools like Oobeya’s Team Health module, which includes Team Symptoms and Team Scorecard components, can help teams gather and analyze data from various sources to identify issues and track progress over time.

Optimizing team performance in software development requires a holistic approach that addresses both technical and cultural aspects of the development process. By implementing these strategies, organizations can improve the overall performance and productivity of their software development teams, delivering high-quality products in a timely and efficient manner.

Resources

See the original post here: https://oobeya.io/blog/optimizing-team-performance-in-software-development/

DORA Metrics Tracking: How to Effectively Detect Production Failures

Emre Dundar — Mon, 30 Jan 2023 14:30:52 +0000

Detecting production failures is the most critical and challenging component of tracking DORA metrics. While it can be challenging, organizations can overcome these challenges by using the right tools and following best practices.

Quick Intro: What Are DORA Metrics?

DORA (DevOps Research and Assessment) metrics are a set of metrics that measure the performance of DevOps practices and processes in organizations. The metrics include lead time, deployment frequency, mean time to restore, change failure rate, and they aim to provide a comprehensive view of an organization’s ability to deliver value to customers. Learn more about DORA Metrics here: https://oobeya.io/blog/how-to-measure-dora-metrics-accurately/

What Is A Production Failure?

One critical component of tracking DORA metrics is detecting production failures. Production failures occur when a change to the software system results in an unintended outcome, causing the system to malfunction or become unavailable. These failures can significantly impact the stability and reliability of software systems, making it crucial for organizations to detect and resolve them as quickly as possible.

The Most Challenging Part of DORA Metrics Tracking: Detecting Production Failures

However, detecting production failures can be a challenging task for organizations. One of the biggest challenges is automatically detecting production failures, which can be difficult due to the complexity of software systems and the limited visibility into production systems. Additionally, organizations are often overwhelmed by the sheer volume of data to be analyzed, making it difficult to identify and resolve failures quickly.

To overcome these challenges, organizations can use a variety of solutions and tools to detect production failures, including monitoring, log analysis, error tracking, user feedback, performance testing, change, and incident management. These tools can provide organizations with real-time insights into the performance and stability of their systems, allowing them to quickly detect and resolve failures.

In addition to using the right tools, organizations can also follow best practices for detecting production failures. These best practices include conducting regular health checks and setting up real-time alerts. By following these best practices, organizations can improve their ability to detect production failures and improve the stability and reliability of their software systems.

How Oobeya Detects Production Failures and Calculates Change Failure Rate + MTTR

Oobeya.io is a software engineering intelligence platform that allows software development organizations to gather and analyze data from various sources to make informed decisions and optimize their development and delivery processes.

Oobeya is also a DORA Metrics Tracking tool that provides valuable insights into the effectiveness of software development and delivery.

Oobeya has a unique mechanism for calculating DORA Metrics across platforms/tools (VCS, CICD, and APM-Incident Management tools) so that any organization can accurately and effortlessly track the journey of a commit from development to production deployment. Furthermore, no changes to workflows or pipelines are required; Oobeya seamlessly integrates with existing tools (GitHub, GitLab, Azure DevOps, Bitbucket, Jenkins, TeamCity, GitHub Actions, GitLab CI, Azure Pipelines, Releases, and more) to calculate DORA metrics.

Oobeya analyzes all deployments, detects production failures, and ties them back to production deployments.

Oobeya calculates all four key DORA Metrics. The Change Failure Rate (CFR) is the percentage of deployments causing a failure in production. This metric provides a clear and concise representation of the stability and reliability of software systems. Oobeya uses the health status of each deployment to calculate the CFR metric.

In Oobeya, each analyzed production deployment has a health status, which is either Success or Failure. Oobeya sets the health status of each deployment by using four methods: manual health status setting, API call, hotfix pattern detection, and tracking incidents from APM/Incident Management tools.

1- Setting Health Status Manually

In this method, the health status of each deployment is set manually by a user. This method is useful when there is a need for verification, for example, when there is a complex deployment that involves multiple systems and applications or where you don’t have any mechanism to detect and track failures automatically by the tools.

2- Setting Health Status Via An API Call

Oobeya provides an API that can be used to set the health status of each deployment.

3- Detecting Hotfix Naming Patterns In The Branch Name, PR, And Deployment Title

To identify hotfix deployments, Oobeya looks for naming patterns in the branch name, Pull Request title, and deployment title. Because hotfix deployments are used to fix critical production issues, Oobeya sets the health status of previous deployments to Failure.

4- Tracking Incidents From Application Performance / Incident Management Tools

Oobeya integrates with Application Performance Management (APM) and Incident Management tools to track incidents in production. If these tools detect an incident in production, Oobeya sets the health status of the most recent deployment prior to the incident to Failure.

P.S. New Relic is ready to use, and DataDog, Sentry, Dynatrace, PagerDuty, OpsGenie, ServiceNow, and more are coming soon.

In addition to automatically and manually setting the health status of deployments and calculating the CFR, Oobeya also provides other three key DORA Metrics and detailed insights into each deployment. This includes information about the deployment time, deployment size (small, medium, large, and gigantic), contributors, and the link to the deployment pipeline. You can group multiple analyses to get a holistic view of DORA Metrics across your organization in the Oobeya Engineering Intelligence Platform.

In conclusion, detecting production failures is the most critical and challenging component of tracking DORA metrics. While it can be challenging, organizations can overcome these challenges by using the right tools and following best practices. By improving their ability to detect and resolve production failures, organizations can deliver value to customers more effectively and improve the overall performance of their DevOps practices.

Resources

See the original post here: https://oobeya.io/blog/dora-metrics-tracking-how-to-effectively-detect-production-failures/
Check out the DORA research here.
How to measure DORA metrics accurately: https://oobeya.io/blog/how-t o-measure-dora-metrics-accurately/

How To Reduce Lead Time For Changes (Optimizing DORA Metrics)

Emre Dundar — Tue, 15 Nov 2022 11:38:23 +0000

A guide to help teams reduce the Lead Time For Changes (DORA Metrics) metric.

In this article, we will take a closer look at one of DORA Metrics, Lead Time For Changes (Change Lead Time), and how it can be reduced to optimize software development and delivery processes.

Metrics are a way of measuring something. They are used to understand the current situation, identify trends, predict future outcomes and make better decisions.

DORA metrics are the best way to measure and improve the health of the software delivery process.

What Are DORA Metrics?

DORA metrics have been widely adopted by organizations across the world. They are now the standard for measuring software value delivery.

DORA metrics are the way to go if you want to measure overall software delivery performance. But what are they basically?

Read my article here: How to Measure DORA Metrics Accurately?

DORA Metrics (a.k.a. Accelerate Metrics & Four Key Metrics)

Lead Time For Changes: The amount of time it takes a commit to get into production.
Deployment Frequency: How often an organization successfully releases to production. High-performing software teams release often and in small batches.
Change Failure Rate: The percentage of deployments causing a failure in production.
Time to Restore Service: How long it takes an organization to recover from a failure in production.

Learn more from Google Cloud's DORA research page: https://www.devops-research.com/research.html

Organizations should measure and track all these four key metrics together to make better decisions and accelerate their value delivery performance.

If you only focus on one or two of these metrics, you will probably make poor decisions. Assume you focused on increasing deployment frequency and decided to reduce testing efforts in order to make more production deployments in a shorter period of time. Your organization/product will most likely lose stability and reliability as a result of your decision.

Focusing on four DORA Metrics is the best and only thing you can do to create a high-performing organization.

But now we will talk about reducing the Lead Time For Changes (while taking care of all DORA Metrics as well).

What is the Lead Time For Changes?

The interval between a code change and its release to the end users is considered Lead Time For Changes.

Lead Time For Changes = [Production Deployment Time] - [First Commit Time of all changes]

The Anatomy of the Lead Time

The image below represents the anatomy of the Lead Time metric.

Let's dive into this breakdown to understand how we can reduce Lead Time For Changes.

The Stages of Lead Time For Changes

Lead Time For Changes mostly measures friction in the coding, code review, and CI/CD processes.

Coding Time: The time elapsed between the First commit and PR opened.
Code Review Time: The time elapsed between the PR opened and PR merged.
Waiting For Deploy: The time elapsed between the PR merged and Deployment pipeline started.
Deployment Time: The time elapsed between the Deployment started and Deployment finished successfully.

How To Reduce the Lead Time For Changes

The best thing you can do to reduce Change Lead Time is to identify software development waste and bottlenecks.

Identifying waste and working on reducing it will automatically reduce the lead time and increase the development teams' productivity!

Let's see how we can optimize the stages of Lead Time for changes:

Optimize Coding Time

Reduce rework in the coding cycles (but first measure Rework)
Work with small batches
Avoid unnecessarily complex solutions (needs technical and domain knowledge)
Avoid multitasking and context switching
Write clear requirements
Fasten the feedback cycle (always the most critical one)

Optimize Code Review Time

Keep it small. If reviewers decide to battle with your changes, it will take too much time to review the PR.
Code faster. Break large features into small pieces and keep the coding time short for each pull request. See the problems earlier.
Review faster. Don't let your code changes stale to prevent potential merge conflicts.
Create a Code Review Checklist
Automate what can be automated in the code review process. Automation is the first gatekeeper of code reviews.
Be ready to be reviewed. Review yourself before submitting. Give it a clear and descriptive title and write the best description.

Check out my article on Code Reviews here.

Optimize Waiting For Deploy Time

Automate your CI/CD process.
Increase your test automation coverage.
Create a strong set of smoke tests, regression tests, etc.
Eliminate manual approval processes.
Reduce pipeline queue time. Improve your CI/CD tooling performance and capability.

Optimize Deployment Time

Identify friction in the CI/CD process.
Reduce CI/CD pipeline duration.
Cache build dependencies.
Optimize container image size.
Check the network latency.
Optimize resources.
Review pipeline architecture.

"Yes, I know where I need to improve!"

These are the magic words that open the doors for effective and sustainable improvement.

If you want to improve the health and performance of your team, you should start by measuring metrics first. Then you'll gain insights into what's going on in your development and delivery cycles (by utilizing trends, benchmarks, patterns, anti-patterns, friction, risks, symptoms, and so on).

You will have the keys to optimizing system performance, team health, developer happiness, productivity, and organizational success once you start saying, 'yes, I know where I need to improve'.

Resources

See the original post here: https://oobeya.io/blog/how-to-reduce-lead-time-for-changes-dora-metrics/
Check out the DORA Research here.
How to measure DORA Metrics Accurately: https://oobeya.io/blog/how-to-measure-dora-metrics-accurately/

Building Healthy Software Development Teams

Emre Dundar — Mon, 24 Jan 2022 07:31:02 +0000

SDLC: A Complex Black Box

The software development life cycle is a complex black box. There are two main reasons:

Reason-1: Software development is craftsmanship. Humans produce software, not machines.

Reason-2: Software development is a deep cognitive activity. There are complex processes in the background we cannot understand and measure.

How To See The Problems?

The main problem in this complex black box is "not seeing the problems": Where do I have bottlenecks? What to improve? Where is the problem?

Every problem produces its own symptom. We need to hear the symptoms of the software development processes to see the problems. The symptoms lead us to the problems.

The Symptoms Of The Software Development

The question is: "What are the symptoms of a software development cycle?"

Another question that guides you to find the answer is:

"What affects the efficiency of my development teams?"

There is a small list of answers, you can also add yours to the list: Complexity, overload, workload, bottlenecks, technical debt, rework, burnout, unhappiness, blockages... That's all about the systems, individuals, and teams, not only the system-level, team-level, or individual-level.

But I wonder about that how many of them do you track? You may feel the need to improve something unclear. Do you really hear these symptoms with real-time data in your development cycle? Or do we all are just flying blind?

How To Build Healthy Software Development Teams?

The software development life cycle is a complex black box, just like the human body. When you ask a doctor about your symptom (e.g., stomachache), the specialist should find the main problem of your body. Therefore, the specialist doctor requires your story, blood test, and/or medical imaging to diagnose first and then to treat the disease.

"Companies are only as healthy as the teams that compose them." (State of Teams Report 2021, Atlassian)

Engineering Leaders vs. Specialists Doctors

Engineering Team Leads are the specialists of their teams.

They are capable of interpreting and understanding the symptoms of their teams. They can pinpoint the main problems that systems, individuals, and teams have in the software development life cycle.

The Key To Healthy Teams: Engineering Efficiency

Invest in managing software engineering efficiency, not only measuring individuals' performances.

Do not look for ways of measuring developer performance. Try to find a way to improve engineering efficiency.

Consider employing an engineering efficiency platform. Integrate it with your SDLC tools (e.g., GitHub, GitLab, AzureDevOps, Bitbucket, Jira, Jenkins, Sonarqube, NewRelic, etc.) and get complete visibility of your development cycle. Then, Engineering Leaders -as the specialist doctors- will easily start monitoring, identifying, and improving their team's health and performance together with the hidden power of engineering efficiency platforms.

6 Steps To Take Control of Your Software Quality

Emre Dundar — Thu, 05 Nov 2020 11:51:51 +0000

See the practical steps to control software quality and meet the software intelligence to level up.

All the product teams want to deliver high-quality products to the end-users to meet customer needs and enhance customer satisfaction. Therefore, the engineering teams try to build more reliable, more secure, more stable, and high-performance software and systems.

There are 6 practical steps below that every engineering team should follow to take control of their software quality. If you want to level up in managing your software quality and development efficiency, check out the bonus section and meet the software intelligence.

1. Track And Visualize Coding Activities

The software development process is a black-box. If you want to see inside the box, you should try to focus on the development activities of your team, such as code commits, pushes, pull/merge requests, code review cycles... Visualizing these activities provides actionable insights into your development processes, helps you identify bottlenecks, reduce lead time, and increase development efficiency.

Check out Git analytics and pull request analytics tools such as QA Dashboard, Pluralsight Flow, GitHub Insights…

2. Analyze Source Code Quality

You can consider code quality as the cornerstone of software quality. Check out the action plan below to enable continuous inspection on code quality.

Enable on-the-fly code analysis by using IDE extensions.
Analyze your code as a part of the CI/CD pipeline.
Set quality gates and break the builds.
Track all issues and make them visible.
Encourage developers to talk about clean code principles, coding standards, etc.
Plan code quality tasks for each sprint.

Check out the code analysis tools such as SonarQube, CAST, Fortify, etc., try to integrate them into your CI/CD pipelines…

3. Care About Code Vulnerabilities

You probably have some security-related issues in your codebase, but you don’t care about them until they have discovered by attackers. Employ a Static Application Security Testing (SAST) tool to analyze your code, detect issues, and own them to solve.

Check out the SAST tools like SonarQube, Checkmarx, WhiteSource and Fortify, try to integrate them on your CI/CD pipelines…

4. Test What You Code

It’s not possible to know that if your software is working properly without testing it. Consider increasing your test coverage by enabling various test types such as unit testing, integration testing, API testing, UI testing, and functional testing…

Check out the testing practices, frameworks, and tools to test what you code. Furthermore, consider using test management tools such as Testinium, Zephyr, TestRail, etc. to monitor test execution results.

5. Monitor Application Performance

Application performance monitoring tools help you understand which problems your end-users are facing (customer satisfaction metrics, APDEX score, etc.) and which problems you have in your application or system (response time, error rate, infrastructure metrics, etc.).

6. Make Your Issues Visible

A software development process always produces issues in all stages of the application life cycle. You should capture, assign, and track the issues, and also you should make them visible. Keep your issues under control, don’t let them hide from you.

BONUS: Meet Software Intelligence

After these practical steps, we need to talk about a new concept to overcome some difficulties.

DevOps toolchain of an organization includes many tools to manage, maintain, and operate all the engineering processes.
Therefore, engineering managers should log in to many different tools, find their projects/teams, get relevant metrics of the projects/teams, and map them all in their brains to see the health and efficiency of their software and teams.

At this point, software intelligence is here for you. Software intelligence provides a complete platform to take control of software quality, identify bottlenecks of the entire development process, and produce actionable metrics to help you improve your software and team performance.

All the tools you use, all the analysis you perform in DevOps, help you get a deeper level of software intelligence. And software intelligence helps you get rid of misinformation and disinformation about your product development process.

QA Dashboard -a brand new software intelligence platform- helps organizations deliver faster, high-quality products by connecting their own SDLC/ALM tools. QA Dashboard enables real-time monitoring of the entire software development life cycle and analyzes coding activities to measure developer productivity.

By enabling QA Dashboard, you get complete visibility into your software health and development efficiency in a single platform.

Accessing real-time data and insights on developers, teams, and products makes you more confident in taking actions on product development and engineering processes.

Let The Power Be With You

If you want to build a high-performing technology organization, it’s time to meet software intelligence with QA Dashboard.

You can learn more about the product, schedule a demo, or see the live demo by visiting QA Dashboard’s website: https://dashboard.qa