Building the perfect internal developer platform

December 20, 2024

Ready to start?

Building the perfect internal developer platform

We all know the challenge: Developers want to focus on building and delivering great software, but the list of non-coding tasks is always growing. They’re juggling complex toolchains, managing infrastructure configurations and keeping environments consistent — all of which take precious time away from writing code. This is where platform engineering steps in to free up developer time and streamline workflows by building internal platforms and portals that address these pain points.

In the recent Google DORA metrics report, platform engineering is defined as a strategic approach to building a foundational environment where infrastructure management and development workflows are unified, consistent and efficient. At the heart of this movement are the platform and the portal. A platform is the underlying setup that supports the development life cycle, while a portal serves as the frontend access point, enabling developers to perform key tasks independently. 

For today’s engineering leaders, the question is not whether to use a platform, but how to make the platform and portal as effective as possible. In a recent webinar, Port and Humanitec demonstrated that by integrating Port’s self-service portal with Humanitec’s orchestration engine, developers can get to coding faster while platform engineers maintain control over infrastructure at scale.

Why platforms and portals matter

Before diving into how a portal and platform orchestrator work together, it’s important to understand why both platforms and portals are critical to software development. 

Think of a platform as the engine room that handles all the heavy lifting behind the scenes. It’s built to reduce the complexity of managing resources and environments, giving developers a streamlined path to the tools they need. Rather than wrestling with cloud infrastructure, spinning up Kubernetes clusters or setting up Terraform scripts, developers can stay in their lane and focus on building features. The platform takes care of the underlying infrastructure, guided by platform engineers who manage the technical details that keep everything running smoothly. It’s a neat division of labor that allows developers to innovate without getting bogged down in technical complexity.

Then there’s the portal. The portal acts as the front door to all the platform’s capabilities — think of it as a concierge service that lets developers request resources or spin up new services with just a few clicks. Need to deploy a new microservice? The portal has a simple, fill-in-the-blank formso you can get your repository, environment and configurations set up in seconds. Once you submit a request, the platform orchestrator automatically takes over in the background, handling provisioning, configuration and deployment without a need for manual setup. For developers, this level of automation and self-service minimizes distractions and allows them to dive straight into the code.

Together, platforms and portals aren’t just tools — they’re enablers of a smoother, faster workflow. With everything centralized and simplified, developers can focus on what they do best, while platform engineers keep things reliable and scalable behind the scenes. It’s a setup that gets everyone working in harmony and keeps the development process moving forward, letting teams deliver value to customers faster and with fewer bumps along the way.

Simplifying the developer experience

For developers, one of the biggest productivity drains is trying to manage infrastructure. Tasks like setting up resources, handling deployment pipelines and configuring services can take up valuable time, pulling them away from what they’re really here to do: write code. Many times, developers don't even know how to do these tasks, since it’s usually the DevOps or platform engineer's job and area of expertise. 

That’s where a well-designed internal developer portal shines, acting as a self-service hub that simplifies infrastructure management and allows developers to focus on building.

Scaffolding a new microservice in Port’s internal developer portal.

With a portal, developers can initiate common tasks like launching a new microservice with just a few clicks. Rather than navigating multiple tools and manually handling configurations, they simply fill out a form within the portal, and the self-service automation takes over: creating a repository, adding essential configurations and setting up the deployment pipeline. The service is automatically deployed into a development environment, letting developers dive straight into coding without a lengthy setup, which not only saves time, but also reduces errors and keeps configurations standardized and consistent across projects.

The power of platform orchestration

While the portal simplifies frontend tasks, the platform orchestrator works with the portal to power the backend, automating complex infrastructure processes. When developers request a resource, such as an S3 bucket, the platform orchestrator provisions it automatically, updating configurations and handling deployments seamlessly across environments.

Adding an S3 bucket to service. Updating the score.yaml file and adding it to an  S3 resource in Port’s internal developer portal

One of the biggest advantages of platform orchestration is its power to keep infrastructure consistent and reliable, reducing the risk of configuration drift and making it easy to move features smoothly from development to production. Picture this: A developer needs an S3 bucket, so they fill out a request form, and the orchestrator takes it from there. It spins up the resource, creates a pull request and deploys it to the development environment, all automatically. No manual steps, fewer errors, faster deployment times and consistent configurations across environments.

Flexibility and customization for all stakeholders

Portals provide not just efficiency but also flexibility. An internal developer portal meets the needs of everyone involved by allowing workflows to be customized for each role. With self-service options, developers can tackle tasks like setting up new microservices or provisioning cloud resources with ease, tailored to fit their tech stack. The portal supports multiple languages, frameworks and cloud providers, enabling developers to work in the environment that’s most relevant to them.

Every role within a development team has different needs, and customizable dashboards give each role the insights that matter most. Developers can check tasks, pull requests and service statuses, while managers track key metrics like deployment frequency and mean time to recover (MTTR). Executives and team leads also gain a big-picture view of development progress that helps them make strategic, data-driven decisions. 

You can extend this customization further, allowing platform engineers to configure views based on organizational goals, team needs or individual preferences. For example, an executive may want to see an overarching view of DORA metrics to track organizational productivity, while a developer’s view might be more task-specific, focusing on pull requests (PRs) and service health. This tailored approach provides clarity and efficiency across roles, ensuring everyone can focus on the metrics and tasks that most matter to them.

Enhancing efficiency for platform engineers

The platform orchestrator also brings significant benefits to platform engineers, who build and maintain the backbone of the infrastructure. Automating the provisioning and configuration of resources allows these engineers to keep the infrastructure environment consistent without getting bogged down by manual processes.

GitHub Actions bot confirms a successful deployment for PR-1, with a link to view details in Humanitec.

For instance, if a developer adds a cloud resource like an S3 bucket, the platform orchestrator updates the configuration files, provisions the resource and makes it available across environments. Later, if the service is deployed to production, the orchestrator manages any necessary updates, keeping configurations consistent without manual intervention. By reducing the operational load, platform engineers can focus on optimizing infrastructure, improving reliability and scaling resources as the organization grows, rather than performing maintenance.

Looking to the future of platform engineering

As the platform engineering movement gathers momentum, there will be more responsibility placed on engineering leaders to establish internal developer platforms and portals that offer a mix of autonomy through self-service actions, simplified workflows and automated infrastructure management. By doing so, engineering organizations can become more efficient and also enhance productivity and innovation.Want to learn more about how an internal developer platform and portal interact? Watch our webinar. If you want to get a feel for what a portal can really do, check out Port’s live demo.

{{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

{{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

{{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