Here are October's release notes. If there is an overarching theme, it is that of personalization and visualization. With new table summaries, we allow you to create valuable home pages, dashboards, and catalog views. With FinOps integrations, we provide you with the data to make those views even more powerful.

With the new table widget, you can display any catalog table in your dashboards by defining custom selections. For instance, a table widget can show all open pull requests or deployments from the last 24 hours. This provides a richer experience to developers and managers.

Using Table summaries you can add better data visualization to dashboards, catalog pages and developer/manager home pages.

Column summary - the bottom row of each table displays a summary of all values for each table column.

Group summary - when applying a "group by" to a table, each group will have summaries for that group for each table column.

This capability offers a quick and easy way to consume data, such as:Table summaries are available in catalog pages and table widgets, as well as dashboards. The current version includes summaries for the following columns: Enum, Scorecards, and Scorecard rules. Stay tuned for more column types in the future.

You can now set action execution permissions according to your blueprint definitions. When configuring permissions to execute an action, the new capability can query the catalog to create a permission condition based on these queries. This enables scenarios such as:See how to define dynamic permissions.

We have added several cost management integrations:With these new integrations, you can easily bring cost data and incorporate it into your catalog by displaying it in different views and dashboards, enabling developers, teams, and managers to stay on top of costs in the organization at any level (service, team, domain, and more).

Refer to our docs to read more about the kubecost, opencost, and AWS cost integrations.

Any user can now generate an access token with their authenticated permissions, enabling anyone to have access control at the API usage level.

To generate a personal token, click on the menu button at the right side of the top navigation menu and click on “Credentials”.

--------------------------------------------------------------------

We have added more integrations that are powered by Ocean 🌊

When filtering the data of a widget, you can now reference user data (such as the user's team). This creates personalized user dashboards.

For example, create a "my open Jira issues" table that will contain only the logged-in user's open issues. This capability is available for all selection-based widgets (pie chart, number chart, and catalog table).

See how to use dynamic filters for widgets.

To help you quickly get up and running with Port, we have created step-by-step guides for common use cases to implement in your developer portal.

Each guide covers an end-to-end developer routine, which can be used by your organization when completing it.

To view the guides, see the guides docs page or go to Port’s guides hub by going to the “Builder” page → click on “Guides” button at the top right of the page.

--------------------------------------------------------------------

Scorecard rules can now be displayed as table columns. This lets you create views focusing on improving specific parts of a scorecard and letting users drill down on scorecards easily right from the table.

The GitLab integration allows exporting of specific folders into catalog entities. This new capability enables visualizing your monorepo services in Port.

See how to use GitLab for monorepos.

We have added the ability to export deployments and environments into catalog entities.

See how to export GitHub deployments and environments.

This month's release notes are all about the developer experience, customizing the developer homepage/dashboard, and helping developers immediately see what's important for them. Additionally, we added tools to make it easier for the portal admins to see which data sources are in use and what they're adding to the portal.

“Data sources” is a new addition to the "Builder" section. It unifies all integrations and APIs in one place. This allows you to:

You can now create dashboards that will appear as a page in the main catalog side menu (in addition to the dashboard tab on the specific entity page). Each dashboard can contain multiple widgets that display graphs and metrics related to your entire catalog, supporting various use cases such as SDLC, DORA metrics, cost management, system performance, and more ✨

Dashboards and catalog pages can be created using the "New" button in the Catalog.

The homepage is now customizable. It supports adding multiple widgets, such as charts, iframes, and markdowns.

Coming soon - create dynamic filters for dashboard widgets. This supports creating a personalized experience on the homepage and any other dashboard.

------------------------------------------

The “related entities” widget automatically displays a specific entity's upstream and downstream relations. Each relation is displayed as a tab with a table containing all related entities.

The “New tab” button allows you to add multiple relation tabs to add relations that are not automatically displayed by the widget and create different views. For example, Adding two deployment tabs, one for staging and one for production.

Read more about the related entities and the “new tab” capability.

The specific entity page is now more customizable! Change the order of the entity page tabs to show the most important content to your users first.

When defining a “webhook” invocation method for a self-service action, we have added the ability to define a “sync” webhook type. When this type is configured, Port will automatically determine the action status according to the HTTP response status code.

This capability is in addition to the already existing “Async” webhook type, in which Port will wait for the action status to be updated via an API call as part of the action’s logic.

Read more about the webhook invocation method.

------------------------------------------

We have added support for mapping GitLab file content into Port using GitLab Advanced Search API. Combined with scorecards, you can define organizational standards across your repositories.

See how to map file content into Port.

We have added support for mapping GitHub teams & GitHub dependebot alerts into Port, allowing you to visualize:See how to map GitHub teams and dependebot alerts into Port.

When creating a “Swagger UI” blueprint property, you can now ingest the API spec as YAML in addition to the URL and object formats.

Read more about the “Swagger UI” property.

August is summer and summer is vacation time. Don’t ask us how we accomplished everything in these release notes… here they are:

1. At last, we launched our open-source extensibility framework project -

2. Ocean lets you easily extend Port’s capabilities by creating new integrations using a robust OSS framework that takes care of all the repetitive work, so you can focus on adding new capabilities to your developer portal. It works well for third party tools as well as anything in-house you’d like to integrate into the portal.

3. You can now expect to see many new integrations coming from Port. With the community, even more 👥

4. We’re really curious to see what the Port community will do with Ocean. You can learn more here

5. In the near future we plan to add capabilities to Ocean, dealing with the backend side of developer self-service actions.

1. Our new Azure integration allows you to collect resource data from Azure and add it to the developer portal.

2. Since the integration is powered by Ocean it supports smart filters and transformations to make it easier to map Azure resources to the desired Port Entities.

3. See how to use the Azure integration.

1. You can now define a Secret input when building the self-service action form. Values that are entered into the Secret input will be encrypted before being sent and will not be saved in Port. This is a great way to let your users enter secrets as part of the self-service actions (such as passwords, private keys, and tokens) in a secure way.

2. See how to add a secret input.

---------------------------------

1. In addition to the Azure exporter mentioned above, we added several highly requested integrations:

2. Jira

3. New Relic

4. SonarQube

5. PagerDuty

1. By installing our GitLab integration, you can now search in files and perform logical checks on file contents to determine whether a file exists in the repository or if files in the repository contain specific keywords.

2. A good example of using this is the ability to check if a repository contains a file and define a scorecard to enforce standards related to it.

3. See how to search in GitLab repository.

1. You can now define scorecards as code using our Terraform Provider.

2. See how to create scorecards in IaC.

1. There is a new property for both self-service actions & blueprint properties that lets you multi-select through a closed list of enums

2. See how to configure it for blueprints and for self-service actions

1. When defining a calculated property, you can now test it in a playground in full page view:

2. We also improved the flow while configuring custom integrations.

1. In addition to the already available Pie chart and Number widgets, you can now use an iframe widget in the dashboard page to specify any external URL and custom component

2. See how to define iframe widget.

1. You can now delete the blueprint and all of its entities from the UI or API without any limit on the number of entities that will be deleted in the operation, all in a single request. Previously there was a limit of 1000 and it required 2 different calls to do so.

2. See how to do this from the API.

It’s August already and although summer is here (and pretty hot ☀️) we’re still working furiously to deliver a better Port. Here’s what we were up to in July:

Our GitLab integration is better than ever! It now supports GitOps, an easier installation, updating the configuration using Port’s UI and more.

We built it from the ground up using 🌊 An open-source framework that effectively lets anyone create an exporter to bring the data they need into Port. We haven’t announced it yet, but it’s already in use. 

See how to configure the GitLab integration.

If you already configured the GitLab using our previous template, you can quickly delete the webhook mappings using the following API call and upgrade to the new integration:

The new global search allows you to quickly search for any object in your catalog from anywhere in Port! The first version includes:The next versions of the global search will include additional search options such as pages, actions, blueprints, and more. Stay tuned!

Terraform makes it easy to integrate Port with your existing IaC definitions. Every resource provisioned by Terraform can also be reported to the software catalog using the same  definition file.

Port Terraform Provider v1.0 is a new framework that provides significantly Improved data access, advanced troubleshooting capabilities, fewer type assertions, and more!

Due to its scale, this new version introduces some breaking changes. Before upgrading, please refer to the full changelog and migration guide.

---------------------------------

You can now use GitOps, Port's K8s exporter, and Port's Entity CRDs to export custom entities into Port. This will enable scenarios such as:See how to use Port CRDs to build a GitOps-based catalog.

Admins can now create, edit, and delete self-service actions using the self-service hub in addition to the “Builder” page.

Do you want to start using Port but don’t know where to start? A simple checklist is now displayed on the “Builder” page, containing all steps needed to get started with Port.

When defining the "average" aggregation for the number chart, you can now calculate a daily, weekly, or monthly average in addition to the existing total average.

This will enable scenarios such as calculating DORA metrics. For example, the "Average weekly deployment frequency" in the last month.

See how to add number charts to your dashboards

---------------------------------

You can now export your entire catalog data to Terraform HCL format in addition to the already existing JSON and YAML formats. This will let you easily manage your catalog alongside your .tf definition files.

1. Admins can now control the order of self-service action inputs using Port’s interface or API, allowing you to tailor the form structure to create an optimal experience when filling out the form.

June is almost over, and here come our product release notes. We’re making great strides with making the product more personalized for developers, with the new homepage as well as better support for developer self-service creation. Data migrations are there since blueprints and data models constantly evolve (as they should) as well as a new addition of an ability to import backstage catalog data.

The new homepage is a user-personalized dashboard containing several widgets with useful information for the user at the personal/team/organizational level/s. The first version of the homepage includes the following widgets:We plan to add more widgets and make the home page flexible, so you can personalize it to meet the needs of users ⚡️🚀

Creating self-service actions is now easier than ever!

You can now configure actions using an intuitive and easy-to-use visual interface (instead of the JSON editor). This new editor includes:You can create/edit actions by going to the “Builder” page → expanding a blueprint → clicking on the “Actions” tab.

Port’s “bring your own data model” approach lets you build a developer portal containing the assets relevant to your organization. This is done through Port’s blueprint capability. We understand that developer portals constantly evolve and that the data model (and blueprints) needs to be regularly adjusted to support new use cases inside the organization.

For that scenario, we added “Data migration” - a way for admins to define data transformation on the catalog to perform data model changes. For example, changing a “String” property to a “Number” property can now be updated on all entities of a specific blueprint in one click.

To use data migrations, go to the “Builder” → expand a blueprint → click on the blueprint’s three dots menu button → click on the “Migrate data” button.

---------------------------------

Do you want to use Port and have some data in a Backstage instance? Now you can transfer your data model and entities from Backstage into Port with a few simple steps.

See how to import data from Backstage.

We have added the ability to trigger a GitLab Pipeline when executing a self-service action.

See how to trigger GitLab Pipelines.

Installing Port’s AWS integration has just become a lot easier.

You can now use pre-made terraform code to create blueprints, install the integration on your AWS account, and ingest data into Port with one terraform apply!

See how to install the AWS integration.

---------------------------------

The new “Export Data” button in the top bar menu allows you to export catalog entities to JSON/GitOps (.YAML) formats.

You can now expand the audit record and see its request body when viewing failed audit logs. This is super useful when debugging data ingestion issues.

A month has passed, and we’re back with our May release notes. This edition is mostly about a better, more navigable layout that supports work even when your developer portal is full of (valuable) data. Tell us what you think: we truly want to hear your comments.

🎨

Port just had a facelift! We improved the UI to make the navigation easier and allow future enhancements (to be added soon) 🚀

The main navigation (catalog, self-service, and builder) is now at the top section of the screen, and there is a new "Catalog" section with a side menu containing all catalog pages. The new side menu can be resized!

📑

At Port, we believe the best developer portals are the ones that can be easily adjusted according to the organization’s needs, for both the data model and user experience. This is why we added more capabilities for admins to further customize the catalog for each user:

The page order in the “Catalog” section can now be changed for all users using drag & drop.

In addition, admins can now control who can view specific catalog pages by clicking on the “Share” button in the page's upper right section.

🔌

Port’s extensibility engine has just become a lot more powerful! With custom integrations, you can extend Port’s data model by integrating with almost any tool and bringing the relevant data into Port’s catalog. The custom integrations use Webhook-based triggers, which can work with most third-party tools and your own custom business logic, allowing anyone to create a new integration.

You can create new custom integrations straight from Port’s interface. This is done by going to Port → “DevPortal Builder” page → clicking on the “ingest data” button → clicking on the “add custom integration” button.

See Port’s complete integration list.

☁️

The new GCP integration allows you to enrich your software catalog with GCP resources. This includes Projects, Storage Buckets, Service Accounts, Memorystores, Compute Instances, Container Clusters, and basically anything GCP.

See how to use the how to use the GCP integration.

-----------------------------

In Port, you can create dashboards with visualizations based on data in your software catalog.

The new “Number” visualization allows you to aggregate and display your catalog data as a number in your dashboard. This can be super useful for scenarios such as high-priority alerts, unsolved vulnerabilities, cloud usage costs, and more.

You can add a new "Number" visualization by going into a specific entity page -> clicking on the "Add visualization" button.

Soon, additional visualizations will be added, such as line charts, bar charts, embedded links, and more. Read more about Port dashboards.

We have added the ability to use GitHub & Bitbucket integrations to map your different services, packages, and libraries from your monorepo into separate entities in Port by automatically scanning your repositories and folders. This way, our integrations support any git configuration - monorepo, polyrepo, or both!

See how to use monorepo with the GitHub integration & Bitbucket integration.

We have made it much easier to edit different elements of your blueprints!

The items in the “Actions” and “Scorecards” tabs are now editable by hovering on an action/scorecard or clicking on the “New action/scorecard” buttons.

Clicking on the new “Edit JSON” button in the blueprint three dots menu will open a menu containing the complete JSONs of the blueprint’s properties, actions, and scorecards.

We have added support for the “Terraform import” functionality. This allows you to import entities and blueprint data from Port into Terraform.

In addition, several improvements have been made to the Terraform provider to ensure the best experience while using it. Read about the Terraform provider.

-----------------------------

When defining scorecard rules, you can use the new "description" property to further explain details about the rule, such as the importance of a rule and the motivation behind it. Descriptions can be added in markdown to add additional formatting, links, and more.

Read more about scorecards here.

Mermaid is a diagramming and charting tool that uses text and code to generate diagrams and charts.

You can now use Mermaid in your Port’s Markdown widgets. To use it, all you need to do is add mermaid syntax to the markdown property in the relevant blueprint.

See how to use Markdown widgets.

When a self-service action that requires manual approval is performed, the approving users will get an email notification requiring them to review the request.

In addition to emails, we have added the ability to send a message to a Slack channel or trigger a webhook.

See how to define notifications.

The payload of a specific run is now displayed in Port’s specific run page and audit log under the “Payload” property.

Port’s GitHub workflow can now update running self-service action data such as status and log messages.

See how to how to update running action with GitHub Workflow.

It’s spring or almost summer, and the skies are getting bluer. Is there a better time to be issuing product news about our blueprint editor, or are only we imagining blue skies when thinking about blueprints? In any case, here is our April product news:

🖼️

The new blueprint visual editor provides a simple interface to edit blueprint properties and relations, instead of the JSON schema we initially offered. In the coming weeks, we'll add a similar capability for the creation of developer self-service actions and scorecards ⚡️🎯

If you prefer working with JSONs to manage blueprints, you still can.

🔌

We added a bunch of built-in integrations that will help you enhance your developer portal:

See the complete integration list

🐱

The new Gitlab integration template allows you to export all your merge requests, microservices, issues, and pipelines from Gitlab into Port in a few minutes! See how to install the Gitlab integration.

You can now run any Azure Pipeline once a self-service action is executed in Port. This saves the need to use a dedicated backend to run your actions. Instead, all the business logic can be inside an Azure Pipeline while Port handles the trigger, staying true to our loosely coupled approach to developer self-service actions. See how to use trigger Azure Pipelines.

Self-service actions enable developers to perform any task while following the “golden path” curated by the DevOps/platform engineer.

The new ״advanced user form configurations״ allow admins to create more customizable experiences for their users who perform self-service actions, through supporting an adaptive user form that supports scenarios such as -See how to use advanced user form configurations.

Port’s Kubernetes template now supports ArgoCD CRDs. This will allow you to manage your Argo Apps and projects alongside your other K8s objects.

You can use it by going to the template center (“DevPortal Builder” page → “Add” button → “Choose from template” button), and choosing the “Map your Kubernetes ecosystem” template.

When a self-service action that requires manual approval is performed, the approving users will get an email notification requiring them to review the request.

We have enhanced the email notification with the details about the form inputs filled in by the user. This will provide additional context about the action to the approving user. See how to define a manual approval step for your actions.

Springtime is here, and so are Port's latest product release notes. Here's what we were up to in March:

🟦🔶🟡

Ever wondered what is the best way to model your developer portal? This feature is for you!

The new “template center” contains many templates to help you quickly set up a developer portal while following best practices. Each template focuses on a specific use case that can be relevant to your developer portal, such as the microservice catalog, K8s visualization, cloud resources catalog, and more.

Admins can access the template center now by going to the “DevPortal Builder” page → clicking on the “add” button → clicking on the “choose from templates” button. You can also change templates by adding elements or using several templates together.

Missing a template? We would love to add it. Please reach out to us by replying to this email or at dudi@getport.io.

☁️

The new AWS integration allows you to automatically collect live data from AWS to enrich your catalog. We support over 500 services out of the box, such as Lambda functions, SQS Queues, SNS Topics, S3 Buckets, and many more.

This integration also supports smart filters and transformations to map your AWS resources to the desired Port Entities. See how to use the AWS integration.

🔌

Port’s extensibility engine has just become a lot more powerful! With “custom integrations”, you can integrate with almost any tool by bringing the relevant data and creating visualizations based on it.

Each integration is Webhook-based, making it easy to update Port on various triggers, such as new Snyk vulnerabilities or an update to a JIRA ticket. See how to create custom integrations.

You can now stream logs on your self-service actions. The logs will be displayed in real-time on the action run page. This is a great way to inform users about the status of the action and information about its progress. See how to use logs.

The GitHub & BitBucket integration configuration is now editable via Port’s UI. This capability is available in the “Git providers” and “GitOps” categories.

You can view & edit the configuration by going to a blueprint’s three dots menu → “Ingest data” button → clicking on one of the GitHub/Bitbucket integrations.

February, despite being a short month, was actually pretty productive in terms of new product features and improvements. The bigger features are:But there are other small or medium features that matter too, so read on.

⚡️

Users can now view all their in-progress actions in a dedicated side menu on the right side of the screen. In this menu, you can view the details of your running actions such as status, affected Entities, and links to drill down into the action run and Entity.

📝

The blueprint integration center is the central place to view all available methods to ingest data into your catalog. We added auto-generated code examples for any ingestion method you choose. The code examples will help you easily get started with ingesting data into the blueprint of your choice. For example, ingesting deployments via GitHub Actions.

To get to the integrations center, click on the “Ingest your data” button that is located inside the Blueprint card or in the Blueprint menu.

🔐

Admins can now define an approval step on chosen self-service actions. This capability will allow setting guardrails on sensitive actions, while still allowing users to perform actions in a self-service manner.

Actions with an approval step will be created in “waiting for approval” status, the approving party will be notified so they can approve or decline the action. See how to configure an approval step.

In some cases, related Entities are owned by the same teams (For example, “Pods” may have the same team as their related “Cluster”). Using team inheritance, you can configure a specific Blueprint to automatically inherit its team from another related Blueprint.

When team inheritance is configured, all Entities of that Blueprint will have the same team as their related Entities. See how to configure team inheritance.

Embedded URL widgets let you embed any publicly available URL in your catalog. From Datadog monitoring for a specific microservice, to the Grafana dashboard showing cluster metrics. You can also embed websites that are protected by SSO authentication.

See how to embed a URL with authentication.

Using the new page locking capability, admins can prevent users from changing the filters and column view settings. This is a great way to create a permanent view and make sure your users are exposed to the exact data they need.

You can use this capability by clicking the “Lock page” button in the page menu at the top right corner.

You can now set permissions to view specific pages in the catalog via the API. This way, admins can create a personalized experience for each user, by exposing them to their relevant pages.

See how to configure page view permissions.

If you would like to easily clear all data and start fresh, you can use the “Delete all Entities” button that’s located on the menu of a specific Blueprint in the “DevPortal Setup” page.

When updating a self-service action run via the API, you can now attach multiple links to the run (instead of one link). See how to update an action run.

Filters for scorecards allow you to decide which entities you would like to evaluate as part of a scorecard. For example, set a “Production readiness” scorecard to be applied only for services that are not defined as “Experimental”. See how to define a scorecard filter.

Feel free to browse our latest updates to see all our new and cool features that’ll help you build a better developer portal. Here's a sneak peak at our new and exciting features. Read about them and more below:# Biggest

⚡️

The “self-service actions hub” is your new place to view and execute all available self-service actions. Enter it by clicking on “Self-Service Hub” in the main menu. In the hub, actions will be displayed according to each user’s permissions.

: self-service actions can still be executed from the software catalog pages.

🔄

Ever wondered how to fill your catalog with data? With the new “Blueprint integration center” you can view all Port’s available (and future) integrations. To see all active integrations of a Blueprint, click on “sync data” in the Blueprint's menu.

Missing an integration? Please reach out to us by replying to this email or at dudi@getport.io.

😺

Until now, self-service actions could be triggered using a Kafka topic, a Webhook, or an Agent. But now, you can automatically trigger a GitHub Workflow when executing an action!

Port will manage for you the trigger and status update, so all you need to do is connect the relevant workflow to expose it to your developers. Check out here how to use Port to trigger GitHub Workflows.

🌐

Want to see a full live example of Port's capabilities? Check out a complete example in our new live demo environment! This environment is publicly available for everyone, so feel free to share it with your colleagues.

You can now add “Team” as a Blueprint property or a self-service action input. For example, adding a “Responsible team” user input when creating a “Scaffold new microservice” action. See how to use team properties.

With Port, you can import and display OpenAPI specification files as Swagger UI tabs on the Entity profile page. Now, you can provide Port the OpenAPI spec URL (instead of the full object), and Port will query the URL the display it in the UI. See how to use the OpenAPI Specification visualization.

You can now import and display AsyncAPI specification files as Swagger UI tabs. By using a special Async API Blueprint property, Port will display the Swagger UI matching the spec file provided in the Entity's profile page. See how to display AsyncAPI specification.

The new filter will automatically present only the Entities that belong to the current user’s team. This capability allows you to build pages that display content according to the user’s ownership and responsibilities. To use the filter, add a new filter and choose the new option.

We have added the ability to configure page view permissions via API. The permissions can be granted to roles, users, and teams. This allows you to tailor the experience by allowing users to see only pages relevant to them. See how to define permissions for pages.

Admins can now manually change the status and link of action runs right from the UI. This can be super useful when testing new actions.

Entities can now be assigned to more than one team. This feature comes in handy when an Entity might have more than one responsible team.