Blog
/
/
The top 10 ways to use an internal developer portal: what we’ve learned from our customers
Internal developer portal

The top 10 ways to use an internal developer portal: what we’ve learned from our customers

Jul 10, 2024
Sooraj Shah
Internal developer portal

Improving developer productivity and experience, better managing standards, abstracting away complexity; these are just some of the headline benefits of using an internal developer portal. There are a (seemingly) endless number of use cases for portals. 

We wanted to establish exactly which are the more popular users of an internal developer portal. To do this, we analyzed the way customers actually use Port and ranked the top 10, by popularity.

| | Use case | % of customers surveyed | How it’s accomplished in the portal | |----|------------------------------------------------------------|-------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | 1 | Discoverability and context | 100% | Creating a software catalog that contains all company resources from CI/CD metadata through cloud, Kubernetes, services, and more, helping developers find what they need and reducing unnecessary duplication. | | 2 | Driving organizational standards | 98% | Scorecards allow you to define clear standards for any entity in the software catalog, ensuring production readiness, code quality, migration quality, operational performance, and more. | | 3 | Shipping faster to production | 90% | Developer self-service provides developers with autonomy to perform routine tasks without filing tickets or waiting for other teams, from spinning up new microservices to creating an ephemeral environment. | | 4 | API governance | 88% | The software catalog shows APIs in context, with enriched metadata and/or structured performance feedback on the quality of the API. Self-service enables you to scaffold a new API. Scorecards help ensure API quality and compliance and initiatives can enable managers to better track progress of API governance improvement. | | 5 | Simplifying Kubernetes for developers | 73% | Self-service actions and software catalog information abstract away K8s complexity for developers, enabling them to work autonomously in cases that would otherwise require K8s knowledge. | | 6 | Reducing MTTR | 60% | On-call use the portal for incident management. The software catalog provides context, and runbooks can be automated, making incident resolution faster. Temporary permissions can be granted to on-call through the portal. | | 7 | Migrations | 56% | The software catalog is used to ensure migration of deprecated versions to ensure services, APIs and packages use the most up-to-date version. | | 8 | Engineering metrics and insights (including DORA metrics) | 44% | The data in the software catalog enables you to create reports and dashboards on engineering metrics, providing much needed insight to managers. | | 9 | Optimizing and contextualizing cloud costs | 42% | You can import and associate resources with their costs in the software catalog. You can provide engineering management with dashboards containing cost information and drive initiatives with developers to reduce cloud costs. | | 10 | Managing feature flags | 23% | The software catalog provides context and self-service actions are used to toggle feature flags on or off, in context. |

1. Discoverability and context (via the software catalog)   

The service catalog is the first element that’s built in an internal developer portal - reflecting the state of the SDLC - because everything in the portal (scorecards, self-service, dashboards) relies on it.A service catalog directly improves the developer experience by enabling developers to: 

  • find the information they need, especially when on-call 
  • reduce the manual work required to update data in other places, such as Jira, spreadsheets or CMDB, and not have to switch between various interfaces, 
  • Grow re-use of services, APIs and more, through the fact that they are discoverable, and
  • adopt InnerSource practices as a result of discoverability. 

Port’s software catalog is populated in a way that prevents maintainability issues (which are common with Backstage). It is also real time, meaning it includes runtime information. Further reading: Top examples of service catalogs in action

2. Drive organizational standards (using scorecards)  

Almost all Port customers use scorecards.Scorecards can grade production readiness, code quality, migration quality, operational performance, and more. By defining scorecards for elements in the organization’s software catalog, organizations both set standards, track them and drive developers to fix non-compliance or make changes when standards evolve. But internal developer portals go beyond just setting standards; they also provide the practices to rectify cases when standards aren’t met. Using production readiness as an example, you can not only monitor assets using dashboards and automated alerts, but also  drive actions for rules that aren’t met - whether it’s missing documentation, a misconfiguration detected or any other compliance issue. And when the time comes to add a new requirement, you can update the relevant scorecard and create an initiative page so everyone can act. 

Further reading: Managing production readiness in an internal developer portal - a how-to guide.

3. Shipping faster to production using developer self-service

One of the key obstacles to developer productivity is waiting for tickets or taking too long to perform certain actions, as a result of cognitive load, too many interfaces or lack of clarity as to how to perform these actions. Developer self-service provides developers with autonomy to perform tasks themselves without filing tickets or waiting for other teams. Our post on defining a portal MVP contains an example of how to create self-service that lets developers ship quicker to production. Self-service actions include scaffolding a new microservice, but also provisioning, terminating and performing day-2 operations, which are often overlooked.  Recently, cybersecurity company Cybersixgill’s director of cloud operations Naveh Katz explained that with developer self-service in the portal, building new microservices takes minutes compared to days without an internal developer portal. 

Further reading: How Cybersixgill has significantly improved developer efficiency with self-service actions

4. Improving API management 

Just like a software catalog addresses microservice proliferation, an API catalog addresses API proliferation, by making APIs discoverable and showing them in context, reducing replication and making it easier to scaffold APIs and track them.
Internal developer portals offer more than traditional API catalogs by showing APIs in context and enriched metadata or structured performance feedback on the quality of the API.Self-service actions in the portal can enable developers to scaffold APIs that are compliant and secure by default, and streamline API lifecycle management. Scorecards help ensure API quality and compliance, while initiatives can enable managers to better track progress of API governance improvement. Meanwhile, dashboards can provide customized information about APIs to different stakeholders. 

Further reading: Manage your APIs using an internal developer portal
                          API catalog vs API developer portal 

5. Simplifying Kubernetes for developers 

With Kubernetes emerging as the de facto cloud development platform, developers have been tasked with interacting with it more and more. However, Kubernetes requires expertise that many developers don’t have. This is why a large proportion of organizations using Port are relying on the internal developer portal to provide them with the right abstractions and guardrails for developer interaction with Kubernetes. Further reading: How to drive a culture of Kubernetes standards with platform engineering

6. Reducing MTTR 

Reducing MTTR factors in the time it takes to fully resolve a failure, including detection, diagnosis, repairing and ensuring it won’t happen again. While incident management tools can handle incident logistics, the burden is on the on-call engineer to resolve it. But anyone on-call needs more support in order to reduce the mean time to resolution (MTTR). The internal developer portal provides on-call with the information they need at their fingertips including being able to answer ‘what are the upstream/downstream dependencies’, identifying the owner of a service, obtaining underlying infrastructure health metrics, and checking if a service is being monitored correctly. Portals also offer automated runbooks, making incident resolution faster. They can also be used to grant temporary access to cloud resources.

These capabilities speed up detection, diagnosis and repair by providing you with context you wouldn’t otherwise have. To reduce the chances of an incident happening again, you can use maturity scorecards to ensure best practices are always upheld, while SREs can define and monitor MTTR (and other metrics) in the portal’s dashboards so you can more readily identify resources prone to incidents, check how long it takes to recover per team and per service, and establish initiatives to improve. 

Further reading: How internal developer portals improve incident management

7. Migrations 

You can use a portal to migrate deprecated versions to ensure services, APIs and packages use the most up-to-date version This is crucial for reducing AppSec risks. Without portals, tracking versions is often carried out manually and it’s not easy to tell which versions are used across the board.

TransferGo used the portal to track the yearly PHP version upgrade initiative it has; it previously relied on Jira and Slack which presented significant communication challenges. Now, it uses Port to communicate initiatives and track them by developer, team and service, reducing the previous manual load on developers.

Further reading: How TransferGo is revolutionizing developer experience with Port   

8. Engineering metrics and insights (including DORA metrics) 

Since the portal contains all the data it can easily be used to create reports and dashboards on engineering metrics, which are often difficult to create elsewhere. Since the portal also provides the option to drive initiatives, standards and self-service, it can both measure and provide the tools to improve these metrics. 

Further reading: Developer experience metrics: best practices, key components and examples  

9. Optimizing and contextualizing cloud costs  

Developers are responsible for optimizing application costs but often lack the necessary context to do so effectively. While they use cloud cost tracking and optimization tools, there's a common issue: stakeholders such as developers, tech leads, product managers, engineering team leaders, and FinOps professionals don't have a clear understanding of the connections between costs, resources, owners, and services.The portal addresses this by allowing users to import and associate resources with their costs. This enables stakeholders to see the costs linked to specific resources and services, along with additional business domain information. Consequently, users can pinpoint areas for cost adjustments and aggregate expenses per domain. 

Further reading: Using an internal developer portal for superior FinOps visibility   

10. Managing feature flags

Feature flags act like switches within your software, allowing you to turn features on or off without deploying new code. This gives you the power to gradually roll out new features, test them on a subset of users, and easily roll them back if anything goes wrong. One of the issues engineering teams have while managing feature flags is a lack of context; there’s a lack of clarity on how these flags connect to various environments and services.When remediating, teams often manually create and update spreadsheets to map out these connections. But this method is far from ideal as it’s time consuming and the information gets outdated quickly.Using a portal to manage feature flags, means you can:

  • Understand exactly where and how feature flags are implemented across different environments.
  • Gain a comprehensive overview of all feature flags used by any given microservice.
  • See all the details about feature flags including configurations, available values, and default values.
  • Gain insights into the specific settings of feature flags, attributes, and associated segments.
  • Toggle on/off features flags while having all the relevant context in the catalog

What else can be done with a developer portal?

There are excellent use-cases that didn’t make it into the top 10 use cases, but we thought that it was worth it to point them out:

Just-in-time permissions

Internal developer portals can increase security by integrating Just-in-time (JIT) permissions. JIT permissions grant developers temporary, elevated access to critical resources only when needed, reducing the risk of unauthorized access and potential security breaches. For developers, this means no more waiting on ticket approvals to access the resources they need, streamlining their workflow. By incorporating JIT permissions into the portal, organizations can streamline access requests, automate approvals, and provide a clear audit trail. Automation further enhances this process by enabling granular rules for JIT permissions. For example, on-call engineers can automatically gain access when their shift begins and have it revoked when their shift ends, ensuring that access is always aligned with operational needs.

Further reading: Managing Just-in-time Permissions in a Developer Portal
See JIT permissions in the live demo https://demo.getport.io/temp_permissions

Unified alerts 

You can use your portal to consolidate alerts from multiple monitoring and/or security tools. This centralized view helps address alert fatigue and provides important context. Developers can quickly see if an alert is from a production or development environment, identify the service owner, and access relevant health metrics. Moreover, because Port dashboards are actionable, developers can directly respond to alerts from within the portal. This could include triggering a runbook or reverting to a previous version of a service, all without leaving the portal. 

Further reading: Alert Management With an Internal Developer Portal | Port
See the unified alert dashboard in the live demohttps://demo.getport.io/code_alerts

Policy enforcement 

Internal developer portals make it easier to enforce company policies. Instead of relying on wikis or training sessions that can be outdated or overlooked, the portal can automatically enforce that developers are following the rules. For example, the portal can prevent developers from deploying a service they’re not authorized to deploy, or it can limit the number of development environments they can create. If a developer needs to break a rule, the portal can automatically require approval from their manager. This helps to ensure that everyone is following the rules and that the company's systems are secure.

Further reading: Announcing: automations

Concluding thoughts

The internal developer portal may initially be used for discoverability and context, to drive organizational standards and to ship software more quickly to production, but it’s clear that engineering teams are looking at numerous other use cases that can help to improve engineering processes and the experience of all of its stakeholders. 
Want to get started with Port but don’t know how? Check out these resources:

Try: Our live demo
Read: Fast-tracking service deployment with Port: a plain vanilla internal developer portal
Use: The portal roadmap planner

{{cta}}

Book a demo right now to check out Port's developer portal yourself

Book a demo
{{jenkins}}

It's a Trap - Jenkins as Self service UI

Read more
{{gitops}}

How do GitOps affect developer experience?

Read more
{{ebook}}

It's a Trap - Jenkins as Self service UI. Click her to download the eBook

Download eBook
{{cyberark}}

Learning from CyberArk - building an internal developer platform in-house

Read more
{{dropdown}}

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

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

Check live demo

No email required

Contact sales for a technical product walkthrough

Let’s start

Open a free Port account. No credit card required

Let’s start

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

Let’s start

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

(no email required)

Let’s start

Contact sales for a technical product walkthrough

Let’s start

Open a free Port account. No credit card required

Let’s start

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

Let’s start

Let us walk you through the platform and catalog the assets of your choice.

I’m ready, let’s start