# Continuous Merge Guide to Improving Code Quality Metrics | LinearB Blog

> The Continuous Merge Guide to Improving Code Quality Metrics breaks down the importance of merge standards, and how LinearB workflow automation can help. 

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._

[Blog](https://linearb.io/blog)

/

Continuous Merge Guide to Improving Code Quality Metrics

# Continuous Merge Guide to Improving Code Quality Metrics

![Photo of Natalie Breuer](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Natalie_Breuer_e5764bbbac?_a=BAVMn6ID0)

By [Natalie Breuer](https://linearb.io/blog/continuous-merge-guide-to-code-quality#natalie-breuer)

|

August 8, 2024

![Continuous_Merge_Guide_to_Improving_Code_Quality_Metrics_006f47c051](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Continuous_Merge_Guide_to_Improving_Code_Quality_Metrics_006f47c051?_a=BAVMn6ID0)

## **Code Quality Metrics and Continuous Merge** 

Every software engineering team deals with their fair share of buggy code. In fact, more than one-third of developers dedicate [25% of their time identifying and resolving bugs](https://www.businesswire.com/news/home/20210216005484/en/Rollbar-Research-Shows-That-Traditional-Error-Monitoring-Is-Missing-the-Mark) – valuable time which could be better spent building new features. When code is well-structured and properly documented, it becomes easier for developers to improve code quality metrics and decrease overall cycle time. 

What’s more, high-quality code is easier to scale as software evolves, allowing for easier integration of new features moving forward. In this guide, we’ll introduce the practice of Continuous Merge and how to start applying its principles to establish and automate merge standards in your organization that will strengthen your code quality metrics.

Want this guide sent directly to your inbox? [**Click here and enter your email!**](https://linearb.io/resources/continuous-merge-guide-to-code-quality)

## **What Is Continuous Merge?**

Continuous Merge is the guiding practice behind how engineering organizations program their delivery pipeline. In essence, it’s a way of implementing workflows that optimize the pull request merge path for both velocity and code quality metrics.

> **Continuous Merge (CM)**
> 
> The practice of automating the classification of pull requests in order to optimize the path to merge. 

Continuous Merge isn’t just a category, it’s a mindset. And as teams adopt its philosophy and introduce pre-merge workflow automation into their processes, they benefit from higher software code quality metrics, adherence to compliance best practices, and fewer bugs. 

Ultimately, adhering to CM practices will allow you to eliminate standard, or one-size-fits-all PR review processes, in lieu of routing PRs based on programmed automations. Doing so will allow your team to optimize their metrics for code quality. 

![Continuous Merge philosophy moves away from old methods that treat all pull requests the same to a new method that routes them into workflows based on their contents.](https://assets.linearb.io/image/upload/v1720000000/Frame_1_f54b2a6e50.jpg)

### **The First Step Towards Continuous Merge** 

Most engineering organizations do not have the visibility or mechanisms in place to enforce or audit merge policy across multiple dev teams. And this inconsistency can give rise to inefficient processes, poor developer experience, increased context switching, and poor code quality metrics.

To take the first step towards Continuous Merge, engineering leaders should start by creating a set of merge standards on their team that will then be adopted as policy at the organizational level. 

> **Merge Standards**
> 
> A set of guidelines that standardize when and how code changes should be merged into a shared codebase.

Adhering to merge standards establishes best practices for code quality metrics in software development, facilitate collaboration, and boost efficiency.

Merge standards dictate the decision for “if” “then” scenarios. When practicing Continuous Merge, your merge standards should balance velocity with quality. 

In this guide, we’ll break down the quality side of this equation. To read more about Continuous Merge and its many benefits, check out our [Guide to Continuous Merge: Merge Standards](https://linearb.io/wp-content/uploads/Continous-Merge-Guide-to-Merge-Standards-LinearB-.pdf). 

## **The Benefits of Quality Merge Standards**

Creating merge standards on your engineering team can significantly improve software code quality metrics in five key areas: 

1. **Consistency:** When all code changes follow a consistent style and structure, the codebase is easier to read and understand, ultimately giving rise to better collaboration and reducing the likelihood of bugs.
2. **Efficiency:** Merge standards provide a clear set of guidelines for reviewers to follow. Now, engineers can focus on higher-level concerns, like functionality and architecture, rather than wasting their time on trivial issues like formatting or naming conventions.
3. **Early Bug Detection:** By enforcing best practices, you can enable your team to spot bugs or issues earlier in the development process. Providing engineers with a merge standards checklist during onboarding will help ensure that they’ll habitually review code thoroughly before merging.
4. **Scalability and Maintainability:** Merge standards promote practices that make it easier for your team to scale over time, while also maintaining a healthy codebase. Well-documented code, proper comments, and clear naming conventions all contribute to optimizing code quality metrics and their impact on software scalability.
5. **Knowledge Sharing:** When everyone adheres to the same standards, it becomes easier for engineers to work on different parts of the codebase and to onboard new hires moving forward. Merge standards that are updated regularly help team members learn from each other’s mistakes and successes.

We suggest using the following merge standards as an example when creating your own, then customizing them to your team's processes as you see fit. From there, you can align at a higher level and reap the benefits of Continuous Merge. 

It’s important to note that merge standards can vary widely org to org (and even team to team), depending on factors like company size, maturity, and methodology. 

## **Merge Standards That Promote Quality**

At LinearB, these are the merge standards our engineering team uses to boost our software code quality metrics:

**Code Experts:** Assign experts to review sensitive code

[**High-Risk Tag**](https://docs.gitstream.cm/automations/standard/review-assignment/review-sensitive-files/)**:** Let DevSecOps take the reins on high-risk work

**Missing Tests:** Mark PRs without tests

**2 Reviewers:** Require additional reviewers for complex PRs

**Deprecated API Alert:** Request changes on deprecated APIs

[**Auto-Approve Sonar Clean Code**](https://docs.gitstream.cm/integrations/sonar/#approve-sonar-clean-code)**:** Automatically approve PRs that receive an 'A' rating from SonarCloud’s quality gate

[**Label SonarCloud Quality Reports:**](https://docs.gitstream.cm/integrations/sonar/#label-sonar)Get a comprehensive report from SonarCloud whenever vulnerabilities, bugs, code smells, or security hotspots are detected.

[**Review Sonar Duplications:**](https://docs.gitstream.cm/integrations/sonar/#review-sonar-duplications)Request changes whenever Sonar reports an excessive level of duplicated code.

[**Flag Sonar Security Alerts:**](https://docs.gitstream.cm/integrations/sonar/#review-sonar-alerts)Require additional reviews whenever a PR fails to pass a SonarCloud quality gate check.

[**Estimated Review Time**](https://docs.gitstream.cm/automations/provide-estimated-time-to-review/)**:** Add color-coded labels to PRs with estimated review time, so devs can prioritize their time accordingly.

[**Welcome Newcomer:**](https://docs.gitstream.cm/automations/welcome-newcomer/)Share a welcome message when a developer opens their first PR to a repo, and provide context to help them figure out what’s next.

**Label Percent New Code:** Post a comment that indicates what percentage of the PR is new code.

[**Flag Deleted Files**](https://docs.gitstream.cm/automations/label-deleted-files/)**:** Label PRs that delete files.

[**Request Screenshot:**](https://docs.gitstream.cm/automations/request-screenshot/)If the PR lacks an image file, apply a no-screenshot label to request a screenshot.

#### Want this guide sent directly to your inbox? 

## **Implementing Quality Merge Standards with Policy-as-Code** 

Engineering teams have two choices when it comes to implementing merge standards: they can do so manually or they can leverage workflow automation.

**Option 1: Manual Adoption**

The first option, albeit time consuming and task-oriented, is certainly do-able. 

To start, we recommend working with your team to evaluate your existing code merge practices. It can be helpful to ask questions like: 

* When we collaborate well, what tend to be the reasons?
* What processes enable devs to get code out the door quicker?
* Which practices help us ensure healthy metrics for code quality?

Once you’ve aligned with your team on what’s most important to standardize, it’s time to create a comprehensive document outlining your team’s new merge standards. Feel free to pull from our team’s list (above) or create your own from scratch.

From there, publish your merge standards somewhere easily accessible, like on your team’s wiki, then conduct a training session to talk through best practices and address any questions or concerns. It can also be helpful to record this session for future hires to review during the onboarding process.

Moving forward, because these standards are subject – and even likely – to change, we recommend evaluating and updating your merge standards at least once a year.

**Option 2: Workflow Automation**

Alternatively, engineering teams have the option to use [a Continuous Merge tool like gitStream](https://linearb.io/platform/gitstream) to create policy-as-code that will automatically enforce your quality standards across all repos. 

With [gitStream](https://linearb.io/platform/gitstream/), engineering teams can customize their code review workflows for each pull request, based on the content of the code. 

Automating Continuous Merge practices using gitStream starts with a simple .cm file that programmatically defines how your PR process is managed. 

Merge standards can help your organization automate the process of building code expertise, manage high-risk PRs, and flag situations where corrective actions are required.

![5 gitStream rules: code experts, high-risk tags, missing tests, 2 reviewers and deprecated API alert.](https://assets.linearb.io/image/upload/v1720000000/CI_e97d845ffa.jpg)

**Code Experts: Assign Experts to Review Sensitive Code** 

When it comes to high-risk code, it’s imperative that changes are thoroughly reviewed by the most qualified person before they are deployed. 

As such, one of the most popular gitStream rules is the ability to assign [codeExperts](https://docs.gitstream.cm/automations/standard/review-assignment/assign-code-experts/) to a review. 

gitStream takes into account which developers have the most commit activity and knowledge on the files in question, then assigns them to review that PR automatically. 

![gitStream's code experts helps you identify your most knowledgeable developers and automatically assign them for code reviews.](https://assets.linearb.io/image/upload/v1720000000/Frame_67156_42a73656e2.jpg)

This way, the code expert can provide specific and informed feedback, rather than general comments that may be lacking vital context. 

gitStream users can leverage this rule to:

* Identify the most knowledgeable and recently active developers to review code
* Distribute the review burden across teams to increase the overall level of expertise
* Automatically assign the best reviewer, thereby improving code quality metrics while decreasing developer toil

> **Developer Toil** 
> 
> The kind of developer work that tends to be manual, repetitive, automatable, tactical, devoid of enduring value, and that scales linearly as a service grows. 

Code Experts can also be used as a replacement for simpler solutions like GitHub’s CODEOWNERS. While CODEOWNERS does allow users to assign developers or teams to specific files, it does not take into account more dynamic data like history, activity, developer expertise or team workload. 

**High-Risk Tags: Let DevSecOps Take the Reins on High-Risk Work** 

Many dev teams love CODEOWNERS because it allows them to flag risky code by file or directory. With gitStream users can also alert engineers based on _code changes_ relevant to their team. 

This is especially useful for reviews in sensitive areas of the codebase. For example, DevSecOps can flag risky code terms to ensure the PRs containing those terms are reviewed by their team. 

![High Risk Tags gitStream automation.](https://assets.linearb.io/image/upload/v1720000000/Image_3a7d978d78.jpg)

In the example above, a gitStream user has added a required label: Security. Doing so will route all PRs with this component to reviewers with write access – in this case, DevSecOps.

**Missing Tests:** **Mark PRs Without Tests** 

gitStream can also flag high-risk PRs in the pipeline, so engineers can spend their time on what matters most and catch bugs before they happen. 

Whenever a PR without a test is opened, gitStream applies a bright red label.

![gitstream identifying and labeling PRs with missing tests.](https://assets.linearb.io/image/upload/v1720000000/Frame_67145_3f505ac2dc.jpg)

Then, once the tests are added and committed, gitStream will automatically remove the label. 

![gitStream removing a missing test label after the developer resolves the problem.](https://assets.linearb.io/image/upload/v1720000000/Frame_67146_7912ebe07d.jpg)

Every developer appreciates added context on their pull requests – and gitStream PR labels come in many different shapes and sizes. 

![PR labels to help improve code quality metrics.](https://assets.linearb.io/image/upload/v1720000000/Frame_67157_c95575abff.jpg)

Here are 6 other ways you can add vital context with PR labels: 

![PR label options, including estimated review time, welcome newcomer, label percent new code, flag deleted files, and request screenshot.](https://assets.linearb.io/image/upload/v1720000000/CI_2_b3c76c0d55.jpg)

**2 Reviewers: Require Extra Reviewers for Complex PRs** 

Historically, when engineering teams have wanted extra reviewers on a PR, they’ve had to increase the required reviewer count for _all_ PRs using GitHub repo settings. 

This lack of flexibility within GitHub has forced engineering managers to choose between two evils: either assigning developers to more PRs than necessary or forgoing a second set of eyes on certain reviews. 

gitStream solves for this dilemma by allowing users to customize rules per repo, like [assigning two reviewers](https://docs.gitstream.cm/automations/additional-review-for-large-pr/#:~:text=FAQ-,Additional%20Review%20for%20Large%20PRs,-Require%202%20reviewers) for:

* PRs with 200+ code changes
* PRs opened by new team members
* PRs with high potential for security risks
* PRs that affect complex components in the codebase

![Extra reviewers automation to help improve code quality.](https://assets.linearb.io/image/upload/v1720000000/git_Stream_Github_b2299d2904.jpg)

In the example above, the user has added a rule that requires two developers to approve PRs with more than 100 lines of code changed under the src directory. 

**Deprecated API Alert: Request Changes on Deprecated APIs**

The best managers are the ones who equip their teams with everything they require without nitpicking or micromanaging. 

Another popular gitStream rule is the ability to trigger a change request automatically whenever a PR includes use of a deprecated API. This allows engineering managers to improve code quality metrics on their team while remaining hands off. 

This way, whenever a developer accidentally opens a PR using an old API, they will get the following automated alert redirecting them toward the preferred API.

![Deprecated API alert.](https://assets.linearb.io/image/upload/v1720000000/Change_Deprecated_Component_light_Automationwith_Code_4d163bbe38.jpg)

## **Enhance Quality Across The Entire SDLC**

Workflow automation doesn’t have to stop at your Git provider – it can also be used to improve code quality metrics across your entire SDLC. 

![gitStream integrations.](https://assets.linearb.io/image/upload/v1720000000/Frame_67176_dccbb61e8d.jpg)

gitStream integrates with an entire suite of CI/CD tooling, including tools that: 

* Boost Code Quality Metrics – SonarCloud
* Improve Documentation – Swimm and Jira
* Strengthen Security – Jit and Dependabot (Coming Soon)

**Auto-Approve Clean Code with gitStream + SonarCloud**

It’s a common misconception that engineering teams must sacrifice the health of their software code quality metrics at the expense of pace. Rather, [DORA research](https://dora.dev/research/) has “consistently shown that speed and stability are outcomes that enable one another. 

To this end, gitStream’s integration with Sonar allows engineering teams with improving code quality metrics through automated testing.

![SonarCloud automation.](https://assets.linearb.io/image/upload/v1720000000/Sonarcloud_light_Automation_Only_cfc0780434.jpg)

Here are 4 gitStream x SonarCloud rules your team can leverage today to enhance your code quality metrics, while getting PRs out the door faster: 

![SonarCloud gitStream Rules.](https://assets.linearb.io/image/upload/v1720000000/CI_3_e68d40b326.jpg)

**Fast-Track Documentation with gitStream + Swimm**

Good documentation is vital for scaling engineering teams, enabling them to streamline the onboarding process, boost code quality metrics, and build & maintain high-quality software more efficiently.

Swimm is a tool designed to improve the documentation and onboarding processes for software development teams, making it easier for developers to understand, collaborate and maintain complex codebases. 

With gitStream x Swimm, users can automatically approve PRs that consist of changes to Swimm files only. 

![gitStream x Swimm automation.](https://assets.linearb.io/image/upload/v1720000000/Image_1_e083df3a59.jpg)

This way, if a developer decides to modify a document (and nothing else), they can go ahead and merge the PR without having to wait. 

#### Want this guide sent directly to your inbox? 

## **The Future of Workflow Automation** 

The way we see it, workflow automation has the potential to eliminate every single manual task that engineers hate, from testing and documentation to compliance and feature flags.

gitStream’s programmable workflow automation has already saved developers thousands of hours, with the average repo seeing a 61% decrease in Cycle Time. 

![gitStream customer results, with repos using gitStream seeing an average 61% decrease in cycle time.](https://assets.linearb.io/image/upload/v1720000000/Screenshot_2023_11_12_at_9_08_42_PM_64fb9bf854.png)

Even now, dev teams can leverage gitStream’s control plane UI that visualizes which gitStream automations have been deployed across their repos or the organization as a whole. 

![gitStream-Github-1.jpg](https://assets.linearb.io/image/upload/v1720000000/git_Stream_Github_1_484c8b870b.jpg)

With standardization and repeatability built into your development workflows, growing teams can optimize their code quality metrics, without having to compromise speed. 

gitStream marks a shift in the way developers will work for years to come. We’re on our way to a world where developer toil is a thing of the past, and engineers can spend their days innovating.

Setting up gitStream takes less than 3 minutes. [Set up your first rule today.](https://linearb.io/platform/gitstream/)

![gitStream instillation.](https://assets.linearb.io/image/upload/v1720000000/Frame_6774_3_1e0d24abe9.jpg)

To learn more about Continuous Merge and how it can be leveraged to optimize every leg of your SDLC, check out our other CM Guides: 

* [Continuous Merge Guide to Merge Standards](https://linearb.io/resources/continuous-merge-white-paper)
* [Continuous Merge Guide to DORA Metrics](https://linearb.io/resources/continuous-merge-guide-to-dora-metrics)

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![Natalie_Breuer_e5764bbbac](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Natalie_Breuer_e5764bbbac?_a=BAVMn6ID0)

## Natalie Breuer

Natalie Breuer, now a Senior Product Marketing Manager at LinearB, has been in the Developer Productivity Insights space since 2019\. A writer at heart, Natalie loves bringing technical topics to life with human stories – bridging the gap between data and storytelling.

## Your next read

[![Cover image for Slack turns channels into the context engine for agentic AI](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_077524ba8b?_a=BAVMn6ID0)](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

Workflow

[Slack turns channels into the context engine for agentic AI](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

Slack Chief Product Officer Jaime DeLanghe breaks down how channels serve as the foundational context layer for human-agent collaboration. Learn why Slack is...

[![Cover image for Code generation is faster than ever, but shipping value isn't](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_code_review_bottleneck_2400x1256_d73333ea46?_a=BAVMn6ID0)](https://linearb.io/blog/code-generation-faster-shipping-isnt)

Workflow

[Code generation is faster than ever, but shipping value isn't](https://linearb.io/blog/code-generation-faster-shipping-isnt)

Your team writes more code than ever, but less reaches production. AI moved the bottleneck to code review. Here's how to measure it and unblock your pipeline.&n...

[![Cover image for AI as a value multiplier: a human-centric approach to engineering leadership](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Servant_Leadership_2400x1256_0cfd4e2a0c?_a=BAVMn6ID0)](https://linearb.io/blog/ai-as-value-multiplier-human-centric-leadership)

Workflow

[AI as a value multiplier: a human-centric approach to engineering leadership](https://linearb.io/blog/ai-as-value-multiplier-human-centric-leadership)

Super.com's Matt Culver explains why AI should be used as a value multiplier, not a cost-cutter, advocating for a human-centric approach to engineering...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Continuous Merge Guide to Improving Code Quality Metrics",
  "url": "https://linearb.io/blog/continuous-merge-guide-to-code-quality",
  "author": {
    "@type": "Person",
    "name": "Natalie Breuer"
  },
  "datePublished": "2023-11-13T14:13:20.321Z",
  "dateModified": "2024-08-08T16:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1723134611/Continuous_Merge_Guide_to_Improving_Code_Quality_Metrics_006f47c051.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "The Continuous Merge Guide to Improving Code Quality Metrics breaks down the importance of merge standards, and how LinearB workflow automation can help. "
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Register now](https://linearb.io/event/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)