Faros: The best software for spotting engineering bottlenecks

If you're struggling to get visibility into engineering bottlenecks, you're not alone. Most engineering leaders face the same challenge: knowing that something is slowing down their teams, but lacking the precise data to identify where the bottleneck actually exists and whether it's worth fixing.

The reality is that spotting bottlenecks in modern software development is harder than it should be. Engineering orgs ship from dozens of tools, multiple repos, and globally distributed teams. Even within a single tool, teams use different workflows, different statuses, and different approaches to the same processes. Work slows down and bottlenecks form, but actually seeing where and understanding why is difficult without end-to-end visibility. 

That’s exactly where Faros comes in and why many teams consider it one of the top tools that highlight engineering bottlenecks across the entire SDLC. 

This article walks you through how Faros, an engineering productivity platform, helps engineering teams identify, benchmark, and address bottlenecks using a structured, data-driven approach. Whether you're dealing with slow code reviews, long lead times, or prolonged incident resolution, the process remains the same: measure and benchmark the end-to-end process, investigate the reasons for your slowest stages, start experimenting with various optimizations, and put in place alerting systems—so you get early warning of forming bottlenecks and become proactive instead of reactive. 

Measure the process end-to-end

You can’t fix what you can’t see. The first step to highlighting engineering bottlenecks efficiently is to measure your processes end-to-end. To do this, you need visibility into how long something takes overall and the length of each stage within that process., which an engineering productivity platform can provide.

Start with the metrics that matter most to your delivery pipeline. Key metrics include:

• Task cycle time: Measures the amount of time it takes to complete a task from start to finish.This gives you a complete view of how a work item flows through your system. 
• PR Cycle Time: Measures how long it takes for a code change to be reviewed and merged into the main codebase.
• DORA Lead Time: Measures the time it takes to deliver software changes (from the moment code is committed to when it's merged and deployed). This is where many teams discover their biggest bottlenecks.
• Mean Time to Recovery (MTTR): Measures how quickly your team can restore service after an incident. Extended MTTR often signals deeper process or tooling issues.

Once you have these measurements, you can see where most time is being spent. 

But here's the critical part: not every bottleneck needs to be fixed. Some bottlenecks are intentional and built into your process by design. For example, a thorough security review that takes three days might be exactly what your organization needs. The goal is to determine if a bottleneck is intentional or something which should be addressed.

Why is spotting engineering bottlenecks harder for larger organizations?

Many enterprises face significant challenges when trying to spot bottlenecks. The commonly stems from:

1. Different tools (multiple data sources for the same data) → It's quite common for different teams or sub-organizations to use different tools. One team might manage their tasks in Jira, another uses Asana, and a third uses GitLab. Or you might have multiple instances of the same tool within a single organization.
2. Same tool, different workflows → This scenario involves projects within a single tool like Jira, wherein different workflows are expressed through different statuses.
3. Same tool, different usage → In this scenario, every team in your organization might be using a tool like Jira, but they're using it very differently. 

This is where many engineering productivity initiatives stall out. Without a unified view, organizations can't accurately measure cycle times across teams, and they certainly can't identify bottlenecks that span multiple tools or workflows. And this is precisely where engineering intelligence tools like Faros can help.

What makes Faros a top tool for highlighting engineering bottlenecks efficiently?

Faros is the top tool for highlighting engineering bottlenecks efficiently because it handles all the complex challenges facing large engineering organizations.

No matter how many different tools your organization uses, Faros connects to them all—SaaS products and homegrown solutions, org structure data from HR systems, developer experience surveys, cost data from business systems, and more. Connectors normalize the data upon ingestion, automatically mapping corresponding data types into our canonical schema.

When there are different workflows used in the same tool, Faros automatically handles status transitions and provides the desired breakdowns based on the level of analysis:

• Each team’s particular workflow is represented in its metrics, so team members can understand their bottlenecks, learn, and affect change where needed.
• At the leadership level, where we’re zoomed out to team-of-teams or larger groups, metrics are abstracted to common statuses like To Do, In Progress, and Done—enough to see bottom-line metrics such as task cycle time and amount of work in progress.

For teams using the same tool differently, normalization is required to report effectively across this variance in tool usage. The Faros approach is to be compatible with how people really work. Data normalization can be handled in a couple of ways:

• By building conditions into chart queries. For example, if you want to look at all high-priority unassigned issues, one team may use P0 and P1, while another uses Critical and High; a custom query can bake these different definitions into a single chart.‍
• By using the platform’s data transform capabilities. For example, one group uses epics to track initiatives, another uses tags on tasks, and a third uses a custom issue type. Faros transforms this data into the initiative portion of our schema, so you can query all initiatives in a single way.

At some point, if maintaining queries or transforms becomes too complex and error-prone, Faros  recommends introducing a few standard options. You don’t force everyone to comply with the same behavior, but ask teams to select one of a handful of approved ways of doing things. This covers the majority of team preferences while keeping in-tool configurations manageable.

Benchmark your metrics to stack-rank your improvement opportunities

Once the bottlenecks have been identified, it’s time to determine which ones are important to fix, and then which ones to tackle first. Faros incorporates many software engineering industry benchmarks and best practices for velocity, quality, reliability, predictability, security, and organizational composition to help you quickly evaluate your situation.

In practice, this means you’ll be able to stack-rank your improvement opportunities by benchmarking your performance against:

• Industry benchmarks: Organizations like to reference industry standards to gain better perspective on their comparative strengths and weaknesses. These popular benchmarks like DORA are often born of extensive research that ties high performance to better financial performance.
• Best practices: What do high-performing teams do differently? Benchmarking against established best practices helps you understand what good looks like across say/do ratios, context switching, unplanned work, and more. 
• Your past performance: How does your team's current performance compare to previous quarters? This historical context changes everything. A net new bottleneck demands investigation. A long-standing bottleneck that's actually improved due to recent concentrated efforts? Stay the course. 
• Other teams in your organization: Internal benchmarking helps you identify which teams have figured out effective solutions you can replicate across the organization.

These benchmarks help you determine priorities (where do we start?), set goals (what should we aim for?), and justify investments (how do we incrementally become world-class?).

Enterprise reality: different teams, different goals, different benchmarks

The enterprise reality is that different teams might have different goals. A team working on customer-facing features might prioritize deployment frequency, while a platform team focuses on reliability and MTTR. 

Faros recognized this reality from the start and designed its engineering productivity platform so every role can easily understand how teams are performing against contextual goals.

• Teams can customize their thresholds for great, good, medium, and bad. These custom thresholds will be utilized for their personalized dashboards featuring team-level metrics and insights. 
• Leaders will get a bird’s-eye view at the organizational level that takes all the personalized thresholds into account and visually identifies hotspots. It will also call out areas of improvement or decline. 

It’s noteworthy that in its 2025 report, DORA echoed this sentiment by newly defining seven distinct team archetypes, their characteristics, and typical performance levels. Furthermore, DORA moved away from their strict four tiers (low, medium, high, elite), and now show 6-7 bands per metric.

Get notified when a bottleneck is forming and why

Measuring and benchmarking are essential, but they're reactive. Faros is the best software for spotting engineering bottlenecks because it sends proactive notifications when stages in your process start taking longer than expected. 

For example, you can get Slack/Teams alerts from your engineering productivity tool when:

• Code review times have increased 25%
• Incident resolution times have increased beyond acceptable thresholds
• PR cycle times are trending upward

But the real power comes from understanding why—and that’s what separates reactive alerts from actionable intelligence.

Lighthouse AI: Root-cause analysis that pinpoints bottleneck origins

Faros provides AI-powered developer productivity insights. Lighthouse AI, its built-in AI engine, applies statistical analysis and machine learning to pinpoint problem areas in specific sub-organizations, repositories, applications, or stages of the SDLC. It automates difficult and time-consuming analysis that would take weeks if done manually.

Lighthouse AI uses a proprietary machine-learning workflow to analyze key engineering metrics against 250+ factors that can impact them. It then presents personalized, team-tailored insights into what's inhibiting or improving performance. It also leverages LLMs to summarize and explain the findings and recommend solutions clearly. The result of combining developer productivity analytics with AI-driven insights is very powerful.

For example, Lighthouse AI can tell you:

• “Reviews are being handled by too few team members, creating a bottleneck.”
• “Reviewers are increasingly spread across multiple geos, adding time due to time-zone gaps.”
• “There’s a spike in incidents related to a third-party outage, which is driving up MTTR.”

Additionally, every week Faros sends a ‘Snap. Spot. Act.’ update directly to your Slack or Teams:

• Snap – A clean snapshot of your key engineering metrics.
• Spot – Highlights of what changed (for better or worse) and whether new bottlenecks are emerging.
• Act – Concrete, team-specific recommendations so you know exactly how to respond.

This combination of alerts + root cause + recommendations is what makes Faros the top tool for highlighting engineering bottlenecks efficiently.

Create customized views for deeper bottleneck analysis

Standard dashboards get you 80% of the way there. But when you're investigating a specific bottleneck, you need the ability to customize your visibility to enhance your analysis.

Let’s take an example: Faros’s standard dashboards measure incident resolution times, allowing you to examine every step of the process across tools and interactions: Detect → Create → Triage → Resolve → Restore. This helps you measure the impact of your changes throughout its cycles.But let’s say your hypothesis is that incident resolution times are influenced by cross-geo delays. You can create a custom chart to incorporate the geographical location of the team members involved. 

A video and media company with 250 engineers used Faros to identify pull requests requiring cross-geo reviews. They merged geo data from Workday with PR data from GitHub, allowing Faros to generate a list of impacted repositories and initiatives. The company executed a large reorganization based on this data to maximize collaboration. The result? 90%+ of PRs are now reviewed in the same geo (up from 50% pre-reorg), with 37.5% faster PR reviews.

Custom alerts and notifications can also be configured to address issues and track changes over time. This level of customization is what transforms a monitoring tool into an investigation platform. When you can slice data exactly the way you need to test a hypothesis, you move from reactive firefighting to proactive optimization.

In this example, an engineering manager sets up a Faros notification when the percentage of KTLO (keeping the lights on) work exceeds 30% in a given sprint.

Keep teams aware of SLAs and pending work

Even with the best bottleneck identification system in place, sometimes work sits idle if someone forgot to follow up. Faros's engineering intelligence tool comes with ready-to-use workflow automations thathelp keep work moving. They remind team members in Slack and Teams when work is pending, for example:

• When X hours have passed since code review was requested
• When vulnerability patching deadline is approaching
• When they're at risk of breaching an external or internal SLA

These reminders make SLAs visible and actionable: they prevent bottlenecks from forming in the first place, and they create accountability without micromanagement. Developers get the information they need, when they need it, and where they need it—without having to constantly check dashboards or rely on a manager to ping them.

When a biotech company with 200 engineers used Faros to define SLO targets for code reviews and map wait times across teams, they achieved 95% of PRs reviewed within their ideal SLO target within just three months. This resulted in a 27% increase in developer productivity, translating to $13.5M in savings and increased developer satisfaction. This is why Faros is one of the best software options for spotting engineering bottlenecks in the real world—not just in a clean demo environment.

Use an LLM to explore your data

Dashboards are powerful, but sometimes you just want to ask a question in plain language. With the Faros AI Assistant, you can chat about your engineering data directly within Slack or Teams. You’ll get fast, contextual answers which are grounded in data from Jira, GitHub, and 100+ integrated tools. No digging. No dashboards. No delay. Just “Ask Faros AI” and get the answer.

The bottom line: Faros is the top tool for highlighting engineering bottlenecks efficiently 

Highlighting engineering bottlenecks efficiently is so much more than just collecting data. It's about having the right data, normalized and contextualized, with the engineering intelligence to tell you not just where bottlenecks exist, but which ones matter and why they're happening.

Faros is the best software for spotting engineering bottlenecks because it combines data collection, measurement, benchmarking, alerting, and investigation capabilities in a single platform. It works across your entire tool stack, normalizes data automatically, and provides insights at the level of granularity you need—whether that's a bird's-eye organizational view or a deep dive into a specific repository or team—so you can see bottlenecks early, understand them deeply, and act on them quickly.

Want to see how Faros's engineering productivity tool can help you identify and eliminate bottlenecks in your engineering organization? Schedule a demo to see it in action.