Introducing Insights - tracking engineering metrics and optimizing them

September 4, 2024

Introducing Insights - tracking engineering metrics and optimizing them

Ready to start?

Today we’re announcing Insights. Insights turn on the light for anything and everything in the SDLC, from standards compliance, to developer productivity, production readiness and more.

Insights provide engineering leaders with all the engineering metrics they need, directly inside the internal developer portal. They leverage the power of the portal as a central system of record for everything engineering. What’s even better is that managers can immediately act upon the data, closing the loop right inside the portal, using it as a lever to drive behaviors that will improve engineering metrics and the developer experience as a whole. 

Want to learn more? Here’s the deeper dive:

Why do you need Insights? 

Engineering leaders (as well as SREs, DevSecOps, FinOps, product managers and more) have many balls up in the air. They need to meet  time-to-market goals, comply with security standards and best practices, keep infrastructure costs under control, meet SLOs – all while keeping developers happy, to attract and retain top talent. 

They need answers to the following: 

  • Are we on track to meet our goals?
  • Where are the bottlenecks in our workflow?
  • How can I support my teams more effectively?
  • What can wait, and what needs immediate action?

But getting engineering metrics straight isn’t simple nor quick. You need to gather data from multiple tools and systems, and it's nearly impossible to make sense of data or agree on how to best measure your engineering. There is no central system of record and not enough context.

That's where Port Insights comes in. It leverages the power of the portal and the software catalog to pull together all the engineering metrics you need, make sense of the data (by adding rich context), and help you make smarter decisions.

Software engineering intelligence and standards too

While existing frameworks like DORA and SPACE and other productivity / quality frameworks offer valuable insights into team productivity, they don’t tell the entire story. So while Port Insights covers the core metrics provided in software engineering intelligence platforms, it also adds metrics that are just as valuable and are core for your success. 

It's not just how quickly your team delivers code; it’s also how your team meets all your organizational standards. It helps managers keep an eye on costs, security vulnerabilities, SLO compliance, adoption of new tools or practices... the list goes on. 

Every engineering organization has unique priorities and challenges. Port Insights gives you the flexibility to track the metrics that matter most to your business, whether you're measuring time-to-market for a critical feature, tracking the impact of a new security initiative, or monitoring the health of your enterprise customers' tenants.

Insights belong in your developer portal

  1. Through its software catalog, a developer portal already acts as a single source of truth for everything SDLC. Since all the data is there, it’s ideal to use the portal to track and measure all your engineering metrics and standards. The software catalog also provides valuable context, by its very nature. This provides valuable data about how different metrics are connected and correlated.

  2. For example, Port can help you see that a very specific team is slow to remediate critical vulnerabilities, or that a slowdown in deployment frequency is happening at the same time as a spike in incidents, or even that a specific code change caused a performance issue.
    Additionally if a key metric drops, you can immediately assess the impact and know which product lines or customers are affected since this context exists in the portal.

Insights in the portal are actionable 

The portal doesn’t just show software catalog entities or metrics. It gives you the power to drive change, since it delivers access to the platform, and therefore to processes and people too. Using the portal you can set alerts, define self-service actions, initiatives, automations and more. With insights, you can identify your pain points, create solutions for them, and measure their impact. By embedding Insights in the portal, you can close the feedback loop to continuously improve your processes.

What you can start improving

We’ve collected many of the metrics you can impact in this Guide to Software Engineering Metrics. Here are some metrics that can be improved using Port Insights:

  • Developer productivity metrics: Such as DORA or SPACE, but also PR open to close, or developer onboarding tracking
  • Production readiness: Are your software catalog entities meeting production readiness standards? Are standards improving or are some areas slipping? 
  • Incident Management: Monitor MTTR, incidents opens vs resolved etc. 
  • Security: number of critical security issues in tier 1 assets, MTTR and more
  • Understanding infrastructure costs by team or business domain.

Here are some examples of how you can use the portal to drive actual change and move your organization forward  :

  • If PR review times are long, you can create automations to nudge reviewers based on certain triggers.
  • If MTTR is high you can add self-service actions to automate hot fixes or allow just-in-time permissions to shorten time to resolution
  • If a new critical vulnerability is detected, you can automatically create Jira tasks for the relevant developers, assigning them to remediate the issue while tracking progress towards resolution within the portal. 
  • In case of high cloud costs, you can re-evaluate the way you permit self-service environment management to developers
This diagram shows how engineering metrics can be improved by delivering better user experiences in the portal

Closing the loop: turning insights into action

Port goes beyond just providing insights. It lets you close the feedback loop by taking action based on those insights. This is where the partnership between engineering leaders and platform teams comes into life.

By collaborating with platform engineers, engineering leaders can identify the key metrics they need to track, while platform teams can leverage their expertise to build experiences in the portal that drive improvements.This partnership ensures that the insights gathered from Port are not just data points, but actionable information that drives positive change within your engineering organization.

Gamification is also an option. You can present selected engineering insights to teams inside their relevant dashboards and homepages. In some cases, you may want to add benchmarks for other teams. They can then be motivated to reflect on their goals and try to exceed them, like a fitness tracker for engineering. 

Sign up for Port and move your organization forward.

{{cta_1}}

Check out Port's pre-populated demo and see what it's all about.

Check live demo

No email required

{{cta_2}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_3}}

Open a free Port account. No credit card required

Let’s start
{{cta_4}}

Watch Port live coding videos - setting up an internal developer portal & platform

Let’s start
{{cta_5}}

Check out Port's pre-populated demo and see what it's all about.

(no email required)

Let’s start
{{cta_6}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_7}}

Open a free Port account. No credit card required

Let’s start
{{cta_8}}

Watch Port live coding videos - setting up an internal developer portal & platform

Let’s start
{{cta-demo}}
{{reading-box-backstage-vs-port}}

Example JSON block

{
  "foo": "bar"
}

Order Domain

{
  "properties": {},
  "relations": {},
  "title": "Orders",
  "identifier": "Orders"
}

Cart System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Cart",
  "title": "Cart"
}

Products System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Products",
  "title": "Products"
}

Cart Resource

{
  "properties": {
    "type": "postgress"
  },
  "relations": {},
  "icon": "GPU",
  "title": "Cart SQL database",
  "identifier": "cart-sql-sb"
}

Cart API

{
 "identifier": "CartAPI",
 "title": "Cart API",
 "blueprint": "API",
 "properties": {
   "type": "Open API"
 },
 "relations": {
   "provider": "CartService"
 },
 "icon": "Link"
}

Core Kafka Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Kafka Library",
  "identifier": "CoreKafkaLibrary"
}

Core Payment Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Payment Library",
  "identifier": "CorePaymentLibrary"
}

Cart Service JSON

{
 "identifier": "CartService",
 "title": "Cart Service",
 "blueprint": "Component",
 "properties": {
   "type": "service"
 },
 "relations": {
   "system": "Cart",
   "resources": [
     "cart-sql-sb"
   ],
   "consumesApi": [],
   "components": [
     "CorePaymentLibrary",
     "CoreKafkaLibrary"
   ]
 },
 "icon": "Cloud"
}

Products Service JSON

{
  "identifier": "ProductsService",
  "title": "Products Service",
  "blueprint": "Component",
  "properties": {
    "type": "service"
  },
  "relations": {
    "system": "Products",
    "consumesApi": [
      "CartAPI"
    ],
    "components": []
  }
}

Component Blueprint

{
 "identifier": "Component",
 "title": "Component",
 "icon": "Cloud",
 "schema": {
   "properties": {
     "type": {
       "enum": [
         "service",
         "library"
       ],
       "icon": "Docs",
       "type": "string",
       "enumColors": {
         "service": "blue",
         "library": "green"
       }
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "system": {
     "target": "System",
     "required": false,
     "many": false
   },
   "resources": {
     "target": "Resource",
     "required": false,
     "many": true
   },
   "consumesApi": {
     "target": "API",
     "required": false,
     "many": true
   },
   "components": {
     "target": "Component",
     "required": false,
     "many": true
   },
   "providesApi": {
     "target": "API",
     "required": false,
     "many": false
   }
 }
}

Resource Blueprint

{
 “identifier”: “Resource”,
 “title”: “Resource”,
 “icon”: “DevopsTool”,
 “schema”: {
   “properties”: {
     “type”: {
       “enum”: [
         “postgress”,
         “kafka-topic”,
         “rabbit-queue”,
         “s3-bucket”
       ],
       “icon”: “Docs”,
       “type”: “string”
     }
   },
   “required”: []
 },
 “mirrorProperties”: {},
 “formulaProperties”: {},
 “calculationProperties”: {},
 “relations”: {}
}

API Blueprint

{
 "identifier": "API",
 "title": "API",
 "icon": "Link",
 "schema": {
   "properties": {
     "type": {
       "type": "string",
       "enum": [
         "Open API",
         "grpc"
       ]
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "provider": {
     "target": "Component",
     "required": true,
     "many": false
   }
 }
}

Domain Blueprint

{
 "identifier": "Domain",
 "title": "Domain",
 "icon": "Server",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {}
}

System Blueprint

{
 "identifier": "System",
 "title": "System",
 "icon": "DevopsTool",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "domain": {
     "target": "Domain",
     "required": true,
     "many": false
   }
 }
}
{{tabel-1}}

Microservices SDLC

  • Scaffold a new microservice

  • Deploy (canary or blue-green)

  • Feature flagging

  • Revert

  • Lock deployments

  • Add Secret

  • Force merge pull request (skip tests on crises)

  • Add environment variable to service

  • Add IaC to the service

  • Upgrade package version

Development environments

  • Spin up a developer environment for 5 days

  • ETL mock data to environment

  • Invite developer to the environment

  • Extend TTL by 3 days

Cloud resources

  • Provision a cloud resource

  • Modify a cloud resource

  • Get permissions to access cloud resource

SRE actions

  • Update pod count

  • Update auto-scaling group

  • Execute incident response runbook automation

Data Engineering

  • Add / Remove / Update Column to table

  • Run Airflow DAG

  • Duplicate table

Backoffice

  • Change customer configuration

  • Update customer software version

  • Upgrade - Downgrade plan tier

  • Create - Delete customer

Machine learning actions

  • Train model

  • Pre-process dataset

  • Deploy

  • A/B testing traffic route

  • Revert

  • Spin up remote Jupyter notebook

{{tabel-2}}

Engineering tools

  • Observability

  • Tasks management

  • CI/CD

  • On-Call management

  • Troubleshooting tools

  • DevSecOps

  • Runbooks

Infrastructure

  • Cloud Resources

  • K8S

  • Containers & Serverless

  • IaC

  • Databases

  • Environments

  • Regions

Software and more

  • Microservices

  • Docker Images

  • Docs

  • APIs

  • 3rd parties

  • Runbooks

  • Cron jobs

Starting with Port is simple, fast and free.

Let’s start