Making Port your own

May 13, 2025

Ready to start?

Making Port your own

Internal developer portals are best when they feel native to your organization—not like a generic, one-size-fits-all tool. Recently, Port has delivered even more immense customization powers so that you can make the portal truly yours

Every feature below was built with flexibility in mind, based on user feedback and real-world needs. For example, one platform engineer explained that Port’s standout benefit is 

“The level of customizability it offers… [you] can craft dashboards for different personas.” 

Our goal at Port is to listen, and we’ve packed recent releases with enhancements that put you in control. 

Port fits your company

Every organization operates its own unique ecosystem, and that often means multiple Port environments, distinct teams, and evolving workflows. Whether you’re pointing developers to a dev portal for testing new actions or to your production portal for mission-critical work, Port adapts to your structure and speaks your brand’s language. 

Custom logo and branding

Give each Port environment its own “look” so users never doubt where they are—and reinforce your brand at every turn.

  • Environment-aware logos: Upload distinct logos for dev, staging, and prod portals. Users immediately know if they’re testing features or working with live systems.
  • Universal theming: Apply your corporate colors to buttons, links, and widget accents—across light and dark modes—for a cohesive, accessible experience.
  • Self-service & responsive: Simply upload your image file, and Port generates optimized versions for any screen size or theme.
Custom Logo
Screenshot: Port’s homepage fully branded with a custom logo, demonstrating the new theming capabilities.

Why it matters: A branded portal builds trust and cuts down confusion, especially when you run multiple Port instances. Developers instantly recognize which environment they’re in by logo and color, reducing costly mistakes (like running tests against production). Plus, a familiar look-and-feel accelerates adoption: teams dive in more confidently when the portal feels like an in-house tool, not a generic third-party app. As Port’s release notes point out, full branding customization “strengthens your team’s identity, and makes everyone feel right at home.”

{{cta_1}}

Users and Teams as first-class blueprints

Turn your org chart into a living, breathing part of your portal—and automate ownership and permissions with ease.

  • Customizable Blueprints: Model Users and Teams directly in Port, adding any properties you need—Slack channels, GitHub usernames, roles, skills, and more.
  • Dynamic ownership links: Use the new “Owning Team” field to tie services or dashboards to the right group, then power dynamic RBAC so permissions follow your real-world structure.
user team blueprint
Screenshot: Team blueprint showing custom fields for skills, timezone, and contact channels.

Why it matters: Your portal is only as insightful as its data. By elevating Users and Teams to first-class entities, you centralize identity and ownership—no more scattered spreadsheets or manual syncs. Imagine incidents auto-routing to the right on-call group, or service pages displaying the exact team Slack channel for faster collaboration. This single source of truth powers everything from access reviews to automated workflows, saving time and safeguarding accuracy.

With these features—environment-aware branding and rich user/team blueprints—Port fits your company’s structure out of the box. Next up, we’ll explore how you can build tailored dashboards and share creation rights so every team can shape the portal around their own needs.

Port fits your workflows

Whether you’re a platform engineer sketching the big picture or a team lead zeroing in on your squad’s metrics, Port adapts to your processes—never the other way around. Here’s how you can tailor Port to fit your exact workflows:

Tailor every entity page with multiple dashboards

Bring your services, libraries, or applications to life with fully customizable overview tabs and up to five distinct dashboards per entity.

  • Drag-and-drop overview dashboards: Turn the static “Overview” tab into a dynamic canvas—add, move, or remove widgets as you would on any dashboard.
  • Multiple persona-driven tabs: Create up to five tabs on each entity page, each with its own name and focus. One tab might spotlight real-time performance, another security posture, and another customer usage.
  • Persistent, shared layouts: Once you configure an overview or dashboard tab, its layout and widgets stick—for everyone.
Customize entity page
Screenshot: A “Staging” entity page showing the “Overview” tab populated with widgets like details, a pod status distribution chart, and a services table.

Why it matters: Different stakeholders need different views of the same service. By combining a fully customizable overview with multiple dashboard tabs, Port lets you serve developers, operators, and managers from the very same page—no extra URLs or portals required. As one TransferGo engineer put it, Port offers “dedicated views per team, role, or user,” so each group sees exactly what they need without noise or clutter.

Supercharge your charts with advanced features

Already building dashboards? Port’s line-chart widget just got a major boost:

  • Cross-entity aggregations: Plot averages, sums, counts, or maxima over time across any set of services—ideal for org-wide metrics like total deployments or cumulative error rates.
  • Historical data support: Include past imports and choose your interval (hour/day/week) to uncover long-term trends alongside real-time data.
  • Custom axis titles & breakdowns: Rename axes and slice by properties (team, region, severity) so every chart tells a clear story.
Line chart
Screenshot: The “Add Line Chart” editor showing aggregating properties (e.g. average over all entities) and historical data selection.

Why it matters: Charts become powerful storytelling tools when you can slice, dice, and compare across your entire fleet. Now, spotting gradual shifts—like creeping error rates—or celebrating positive trends—like rising deployment velocity—is one click away.

Clone & tweak widgets in a flash

Once you’ve crafted that perfect performance chart, why rebuild it for other contexts?

  • One-click duplication: Clone any widget on dashboards or homepages—queries, filters, and display settings included.
  • Rapid iteration: Tweak one or two parameters (time range, entity filter) and instantly have a fresh view ready to go.

Why it matters: Consistency and speed. Dashboard elements often share similar configurations—now you can reuse what works, experiment freely, and keep everyone aligned without manual rework.

Delegate dashboard creation

Finally, open up the portal creation process to the experts on the ground:

  • Fine-grained permissions: Grant users or entire teams the right to create, edit, or publish catalog and dashboard pages.
  • Domain-specific ownership: Dashboards for services, projects, or business areas are handed off to the experts themselves, while admins retain a global overview.
Page permissions
Screenshot: New page permissions in Port. You can assign specific teams or users to view/edit each dashboard or catalog page.

Why it matters: Platform teams shouldn’t be the sole gatekeepers of portal content. By delegating dashboard and page management, you empower every group—from QA to product management—to craft the views they need, when they need them. The result is fresher, more relevant data surfaces and a sense of ownership that drives portal adoption.

With these combined capabilities—customizable overviews, persona-driven tabs, supercharged charts, widget cloning, and delegated page ownership—Port truly fits your workflow end-to-end. 

Port fits you

Just as Port adapts to your company’s identity and your team’s workflows, it also respects your personal preferences—making every login feel comfortable and consistent.

Dark mode and system theme syncing

Modern apps need to respect your environment. Port now offers:

  • Native dark mode: Choose a sleek, eye-friendly dark theme from your profile. All built-in pages, charts, and tables switch to dark colors instantly.
  • Automatic theme sync: Opt in for System Theme, and Port will detect your OS’s light/dark setting and switch the portal theme accordingly—no more toggling.

Why it matters: A portal that mirrors your device’s theme feels like a native extension of your workflow. Dark mode reduces eye strain during extended sessions, while automatic syncing ensures you never have to pause your work to adjust settings—keeping your focus squarely on building great products.

Dark_mode
Screenshot: Port’s new Dark Mode gives the homepage a sleek, low-light-friendly look.

Flexibility above all

Together, these updates mean that out of the box, Port is the most flexible, user-centric internal portal on the market. We’ve seen teams migrate from rigid systems (or do-it-yourself portals) and immediately take advantage of Port’s customization features. No other solution gives you this level of control without heavy engineering effort. 

A recent Port user summarized it best: 

“We wanted flexibility; Port has high customizability, we could build our [IDP] based on our needs, [which means] we would get long-term value with Port.” 

Unlike alternatives that force you into a fixed data model, Port lets you bring your organization’s structure into the portal.

Port’s mission has always been to listen to platform engineers and iterate quickly. These features stem directly from user feedback – Port customers told us what they needed, and we built it. We’ll continue evolving the product by partnering with you.

Ready to make Port your own? 

There's no better time to migrate if you’re evaluating an internal portal or growing beyond the basics. Port offers free tiers and easy onboarding workflows. Try the new theming, widgets, and blueprints today, and share your feedback with our team. Port’s door is open – let’s build the future of your developer experience together.

{{cta-demo-baner}}

{{survey-buttons}}

Get your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{survey}}

Download your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{roadmap}}

Free Roadmap planner for Platform Engineering teams

  • Set Clear Goals for Your Portal

  • Define Features and Milestones

  • Stay Aligned and Keep Moving Forward

{{rfp}}

Free RFP template for Internal Developer Portal

Creating an RFP for an internal developer portal doesn’t have to be complex. Our template gives you a streamlined path to start strong and ensure you’re covering all the key details.

{{ai_jq}}

Leverage AI to generate optimized JQ commands

test them in real-time, and refine your approach instantly. This powerful tool lets you experiment, troubleshoot, and fine-tune your queries—taking your development workflow to the next level.

{{cta_1}}

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

Check live demo

No email required

{{cta_survey}}

Check out the 2025 State of Internal Developer Portals report

See the full report

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 walkthrough of Port

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}}
{{cta-backstage-docs-button}}

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