add solutions tab

docs/solutions/_category_.json

@@ -0,0 +1,6 @@
+{
+  "position": 0,
+  "className": "hidden",
+  "collapsible": false,
+  "collapsed": false
+}

docs/solutions/engineering360/Overview/Overview.md

@@ -0,0 +1,78 @@
+
+
+# Overview
+
+### Why Software Engineering Intelligence (SEI) Matters
+
+At Port, we recognize that engineering organizations thrive when decisions are grounded in clarity and precision. Software Engineering Intelligence (SEI) offers the visibility needed to transform intuition into insight, empowering teams to optimize software delivery and enhance the developer experience simultaneously.
+
+Engineering360 is Port’s SEI solution, designed to combine objective engineering performance data—such as DORA metrics—with qualitative developer sentiment gathered through targeted surveys. This approach addresses two pivotal questions every engineering leader should consider:
+
+- How effectively is our engineering organization delivering software?
+- How satisfied and empowered are our developers in their daily work?
+
+### Why Combine DORA Metrics with Developer Sentiment?
+DORA metrics—Deployment Frequency, Lead Time, Change Failure Rate, and Mean Time to Recovery—offer vital data about the health and efficiency of your software delivery processes. However, they only tell part of the story. To genuinely improve performance, you must understand the "why" behind these metrics.
+
+Developer sentiment surveys complement DORA metrics by shedding light on the experiences and challenges your teams face daily. They reveal human factors affecting performance, such as process friction, tooling bottlenecks, or team dynamics that pure data metrics alone cannot capture.
+
+For example, if deployment frequency declines and surveys simultaneously indicate widespread frustration with unreliable CI/CD pipelines, you can directly correlate these insights to identify and resolve the underlying issues causing these disruptions.
+
+Engineering360 bridges these perspectives, enabling engineering leaders to:
+- Identify not just what is happening, but why.
+- Take proactive, targeted actions based on reliable data.
+- Improve developer satisfaction, directly enhancing productivity, retention, and engagement.
+
+### From Insight to Action—All Within Your Internal Developer Portal
+
+While numerous tools exist for measuring engineering health, from dashboards to developer analytics platforms, Port aims to go further. With Engineering360, insights are transformed into actions within your internal developer portal.
+
+By integrating DORA metrics and developer sentiment directly into your portal, Engineering360 allows you to:
+
+#### 1. Discover your team’s blockers   
+Use a combination of engineering metrics and developer feedback to uncover friction points that are slowing your teams down.
+#### 2. Focus on the biggest bottleneck   
+Prioritize the most impactful blockers by correlating quantitative data with real survey responses, ensuring your efforts target what matters most.
+#### 3. Clear them inside Port   
+Resolve bottlenecks directly within your portal using Port’s automations, self-service actions, or custom workflows—making it easy to drive meaningful change as part of everyday work.
+#### 4. Show your velocity gains   
+Track and communicate improvements in delivery metrics and developer satisfaction with out-of-the-box dashboards, proving ROI and motivating further progress.
+
+This approach ensures that improvements are not only identified but also implemented effectively, enhancing both visibility and velocity.
+
+For instance, consider a scenario where deployment frequency declines—a key DORA metric indicating potential issues in the delivery pipeline. Simultaneously, developer surveys reveal growing frustration with flaky CI/CD pipelines. Engineering360 correlates these insights, pinpointing the unreliable pipelines as the root cause. Within the internal developer portal, teams can access self-service actions to rerun failed pipelines or retrieve logs, while automated alerts notify the DevOps team when pipeline failures exceed a certain threshold, prompting immediate investigation.
+
+In another case, an increase in lead time for changes is observed, coupled with developer feedback highlighting delays in code reviews. Engineering360 identifies this bottleneck and facilitates a solution through the portal by introducing a dashboard displaying pending pull requests and their statuses. Automated reminders are sent to reviewers for PRs exceeding a set timeframe, ensuring timely code reviews and reducing lead times.
+
+By unifying insights and actions, Engineering360 empowers teams to move beyond reactive problem-solving towards proactive improvement, ensuring that developer experience and software delivery performance continually evolve in tandem.
+
+### Who Benefits from Engineering360?
+Engineering360 supports stakeholders across the engineering organization:
+- VPs of Engineering gain clear visibility into organizational health, enabling strategic decisions backed by actionable insights.
+
+- Platform Engineers leverage detailed performance and sentiment data to optimize tooling, infrastructure, and processes that directly impact developers’ daily workflows.
+
+
+- Developer Experience (DevEx) Leads use qualitative insights to understand developers' pain points deeply and craft tailored interventions that boost morale, productivity, and team cohesion.
+
+### When to Introduce Engineering360 into Your Portal Journey
+Introducing Engineering360 is recommended once your Internal Developer Portal (IDP) foundation is in place—after onboarding your services, integrations, and basic workflows. It's the natural next step in your maturity, transitioning from cataloging and basic operations to actively measuring, analyzing, and continuously improving engineering practices.
+Integrating Engineering360 early in your portal journey ensures a culture of transparency, accountability, and continuous improvement from the outset, helping your organization scale effectively and sustainably.
+
+### Key Outcomes and ROI
+
+With Engineering360, engineering leaders can expect to achieve:
+
+- Reduced friction: Quickly identify and remove process bottlenecks, enabling faster software delivery.
+
+
+- Improved stability and reliability: Leverage data-driven retrospectives to lower change failure rates and accelerate incident recovery.
+
+
+- Higher developer satisfaction and productivity: Address developers' actual pain points, enhancing job satisfaction and reducing attrition.
+
+
+- Continuous improvement: Establish a repeatable, measurable cycle of improvement that aligns developer experience with organizational performance goals.
+
+
+Engineering360 is your pathway to a developer-centric engineering culture.

docs/solutions/engineering360/Overview/_category_.json

@@ -0,0 +1,4 @@
+{
+    "label": "Overview",
+    "position": 1
+}

docs/solutions/engineering360/Quickstart/Quickstart.md

@@ -0,0 +1,91 @@
+# Quickstart
+Ready to get started with Engineering360? This quickstart guide will walk you through setting up DORA metrics and developer surveys in Port. We’ll cover the basic setup steps, prerequisites, and how to see your data flowing in. By the end, you’ll have all the foundational components in place and your Engineering360 dashboards up and running.
+
+## DORA Metrics
+### Prerequisites
+Before installing Engineering360 DORA metrics components, ensure the following prerequisites are in place:
+- Admin permissions (in order to install the experience and execute self-service actions).
+- A connected GitHub integration (for deployment tracking) or access to custom API setup.
+- A connected PagerDuty integration (for incident tracking) or access to custom API setup.
+
+### Install the experience
+
+1. Go to your software catalog.
+
+2. Click on the + New button in the left sidebar, then choose New experience.
+
+3. In the modal, choose New DORA metrics dashboard.
+
+4. Choose a title for your dashboard and click Create.
+
+*put here image*
+
+### Configure your deployments & incidents
+After installation, you need to:
+
+1. Configure Deployments:
+
+- Choose the relevant deployment method according to your organization's definition of a deployment (Merged PRs, GitHub Workflows, GitHub Releases, Github Deployments, Custom API, etc).
+- Apply filters (target branch, PR labels, etc) to align with your process.
+
+2. Configure Incidents:
+
+- Choose the relevant incident method according to your organization's definition of an incident (PagerDuty, Custom API, etc).
+- Connect to a source like PagerDuty or configure via Custom API.
+
+### Track results
+Navigate to the DORA metrics dashboard created in the "DORA setup & dashboard" folder in your software catalog.
+
+Once your data starts accumulating, you will see visualized metrics including:
+
+- Deployment frequency.
+- Lead time for changes.
+- Mean time to recovery (MTTR).
+- Change failure rate.
+
+These metrics give you a high-level view of your engineering velocity and reliability, helping your team identify areas for improvement.
+
+
+## Surveys
+### Prerequisites
+Before installing Engineering360 surveys components, ensure the following prerequisites are in place:
+- Admin permissions (in order to install the experience and execute self-service actions).
+- A communication channel (e.g., Slack, email) to distribute survey links.
+
+### Install the experience
+
+1. Go to your software catalog.
+
+2. Click on the + New button in the left sidebar, then choose New experience.
+
+3. In the modal, choose New Survey.
+
+4. Choose a survey type and give it a unique identifier (this will allow you to run this survey multiple times and track its results over time).
+
+*put here image*
+
+### Configure & distribute the survey
+After installation, you need to:
+
+1. Adjust Survey Visibility:
+
+- Go to the self-service page of your portal.
+- Find the survey, then click the ... button and select Edit.
+- Go to the Permissions tab and configure who can respond to the survey (i.e. who can execute this action)
+
+2. Distribute the Survey:
+
+- Hover over the action card, then click on the chain icon to copy the link to the survey.
+
+*put here image*
+
+### View results
+Navigate to the survey dashboard created in the "DORA setup & dashboard" folder in your software catalog.
+
+Once responses are submitted, you'll see developer sentiment and trends visualized in real time.
+
+*put here image*
+
+These insights help platform and engineering teams understand friction points, monitor developer experience, and prioritize where to invest future resources.
+
+

docs/solutions/engineering360/Quickstart/_category_.json

@@ -0,0 +1,4 @@
+{
+    "label": "Quickstart",
+    "position": 2
+}

docs/solutions/engineering360/_category_.json

@@ -0,0 +1,4 @@
+{
+    "label": "Engineering360",
+    "position": 1
+}

docs/solutions/engineering360/advanced-configuration/_category_.json

@@ -0,0 +1,4 @@
+{
+    "label": "Advanced Configuration",
+    "position": 4
+}

docs/solutions/engineering360/advanced-configuration/advanced-configuration.md

@@ -0,0 +1,19 @@
+# Advanced configuration
+Go beyond the basics and make Engineering360 fit your organization’s unique workflows.
+
+This section covers everything you need to know about advanced setup, integration options, and customizing how DORA metrics and developer surveys work in Port. Here you’ll find:
+
+- What Gets Installed: See all the components, blueprints, dashboards, and automations that Engineering360 provisions in your portal.
+
+
+- Customizing DORA Metrics: Step-by-step guides for integrating with GitHub, GitLab, Jira, PagerDuty, or your own systems.
+
+
+- Customizing Developer Surveys: How to tailor surveys, set permissions, and boost engagement.
+
+
+- API and Custom Sources: Bring in your own data and trigger workflows unique to your teams.
+
+
+Use the links in the sidebar to jump straight to your topic of interest.
+

docs/solutions/engineering360/advanced-configuration/customizing-dora-metrics/_category_.json

@@ -0,0 +1,4 @@
+{
+    "label": "Customizing DORA Metrics",
+    "position": 2
+}

docs/solutions/engineering360/advanced-configuration/customizing-dora-metrics/custom-api/_category_.json

@@ -0,0 +1,4 @@
+{
+    "label": "Custom API",
+    "position": 5
+}

docs/solutions/engineering360/advanced-configuration/customizing-dora-metrics/custom-api/custom-api.md

@@ -0,0 +1,147 @@
+# Custom API Integration for DORA Metrics
+
+If your team relies on custom tooling, internal scripts, or external systems, Port’s API integration enables you to track both deployments and incidents directly. This flexible approach ensures that your DORA metrics accurately reflect your unique workflows, regardless of your underlying technologies or systems.
+
+### Prerequisites
+- An installed DORA Metrics experience.
+- Admin permissions in Port.
+
+### Get started
+
+**1. Obtain your client ID and client secret**
+- In Port, click the ... menu in the top right corner.
+- Select Credentials.
+- Copy your client ID and client secret for API authentication.
+
+**2. Create a deployment entity (Python)**
+Use the client credentials from the previous step to retrieve an API access token,
+Then send a POST request to the Port API to create a deployment entity.
+
+Below is an example using Python:
+```python
+import requests
+
+# Consider using environment variables instead of the hardcoded values
+CLIENT_ID = "YOUR_CLIENT_ID"
+CLIENT_SECRET = "YOUR_CLIENT_SECRET"
+PORT_API_URL = "https://api.port.io"
+
+# Step 1: Get the access token
+
+auth_response = requests.post(
+    f"{PORT_API_URL}/v1/auth/access_token",
+    json={
+        "clientId": CLIENT_ID,
+        "clientSecret": CLIENT_SECRET
+    }
+)
+
+auth_response.raise_for_status()
+access_token = auth_response.json().get("accessToken")
+
+# Step 2: Use the access token to create a deployment entity
+
+blueprint_id = "dora_deployment"
+
+entity = {
+    "identifier": "some_deployment_1", # Unique identifier for the deployment
+    "title": "Some Deployment",
+    "properties": {
+        "lead_time_hours": 0,
+        "deployment_time": "2025-01-01T00:00:00.000Z",
+        "deployment_type": "Custom API",
+        "environment": "production",
+        "status": "success"
+    },
+    "relations": {
+        "group": "all_teams"
+    }
+}
+
+headers = {
+    "Authorization": f"Bearer {access_token}"
+}
+
+res = requests.post(
+    f"{PORT_API_URL}/v1/blueprints/{blueprint_id}/entities?upsert=true",
+    json=entity,
+    headers=headers
+)
+
+res.raise_for_status()
+```
+
+**3. Create an incident entity (Python)**
+
+Similarly, create incidents using Port's API:
+
+```python
+import requests
+
+# Consider using environment variables instead of the hardcoded values
+CLIENT_ID = "YOUR_CLIENT_ID"
+CLIENT_SECRET = "YOUR_CLIENT_SECRET"
+PORT_API_URL = "https://api.port.io"
+
+# Step 1: Get the access token
+
+auth_response = requests.post(
+    f"{PORT_API_URL}/v1/auth/access_token",
+    json={
+        "clientId": CLIENT_ID,
+        "clientSecret": CLIENT_SECRET
+    }
+)
+
+auth_response.raise_for_status()
+access_token = auth_response.json().get("accessToken")
+
+# Step 2: Use the access token to create an incident entity
+
+blueprint_id = "dora_incident"
+
+entity = {
+    "identifier": "some_incident_1",
+    "title": "Some Incident",
+    "properties": {
+        "incident_type": "Custom incident",
+        "description": "some description",
+        "status": "resolved",
+        "incident_url": "https://example.com",
+        "created_at": "2025-01-01T00:00:00.000Z",
+        "resolved_at": "2025-01-01T00:00:00.000Z",
+        "priority": "low",
+        "time_to_resolve": 0,
+        "urgency": "low"
+    },
+    "relations": {
+        "group": "all_teams"
+    }
+}
+
+headers = {
+    "Authorization": f"Bearer {access_token}"
+}
+
+res = requests.post(
+    f"{PORT_API_URL}/v1/blueprints/{blueprint_id}/entities?upsert=true",
+    json=entity,
+    headers=headers
+)
+
+res.raise_for_status()
+```
+
+### Advanced Use Cases
+
+**Automated Event Tracking**: Incorporate API calls into existing CI/CD pipelines or incident management scripts for automatic tracking.
+
+**Contextual Insights**: Add relations to teams or services to enhance analytics within your DORA dashboards.
+
+### Tips & Best practices
+
+Use environment variables or a secrets manager for credentials—avoid hardcoding sensitive data in scripts.
+Refer to the Port API reference documentation for more advanced use cases, such as updating or deleting entities.
+
+With this custom API approach, you can bring any deployment or incident event into Port for unified, accurate DORA tracking—no matter where or how it happens in your software delivery pipeline.
+

docs/solutions/engineering360/advanced-configuration/customizing-dora-metrics/customizing-dora-metrics.md

@@ -0,0 +1,3 @@
+# Customizing DORA metrics
+
+Engineering360 gives you flexibility in how DORA metrics are tracked and managed in your portal. On this page, you’ll find guidance for tailoring DORA metrics data collection to your stack—whether you want to use GitHub, GitLab, Jira, PagerDuty, or custom sources for deployments and incidents. Explore the subpages below for step-by-step integration and configuration guides, and learn how to map deployments and incidents to your own services and teams for actionable insights that truly reflect your organization workflows.

docs/solutions/engineering360/advanced-configuration/customizing-dora-metrics/github/_category_.json

@@ -0,0 +1,4 @@
+{
+    "label": "GitHub integration",
+    "position": 1
+}