For an internal developer portal, the most valuable integrations are the ones that let developers discover, operate, and change software from one place. The “right” set depends on what pain you’re solving, but in practice the highest-impact integrations usually cluster into these categories:

1) Source control and code hosting

Examples: GitHub, GitLab, Bitbucket
Why it matters: This is the system of record for services, ownership, PRs, branches, and release history.
What to surface:

• Repository-to-service mapping
• Owners and CODEOWNERS
• Open PRs, recent commits, release tags
• Default branches and repo metadata

2) CI/CD pipelines

Examples: GitHub Actions, GitLab CI, Jenkins, CircleCI, Argo CD, Tekton, Azure DevOps
Why it matters: Developers want to see build/deploy status and trigger workflows without hunting across tools.
What to surface:

• Latest build status
• Deployment history
• Environment promotion status
• Failed pipeline links and logs
• Manual deployment actions or approvals

3) Runtime / infrastructure platforms

Examples: Kubernetes, AWS, GCP, Azure, Terraform Cloud, Helm, Argo CD, Datadog Infrastructure
Why it matters: This gives the portal a live view of what’s actually running.
What to surface:

• Service health and replicas
• Cluster/namespace ownership
• Infrastructure resources
• Environment info
• Cost and capacity signals

4) Observability

Examples: Datadog, Prometheus/Grafana, New Relic, Splunk, OpenTelemetry backends
Why it matters: Developers need fast access to logs, metrics, traces, and alerts when something breaks.
What to surface:

• Service dashboards
• Error rates, latency, saturation
• Recent incidents/alerts
• Log/trace deep links
• SLO status and burn rates

5) Incident management and on-call

Examples: PagerDuty, Opsgenie, Jira Service Management, ServiceNow
Why it matters: A portal becomes much more useful when it helps answer “who’s on call?” and “what’s broken?”
What to surface:

• Current on-call person/team
• Active incidents
• Escalation policies
• Incident timelines/postmortems
• Service ownership during incidents

6) Service catalog / metadata source

Examples: Backstage catalog, internal CMDB, spreadsheets (initially), custom metadata store
Why it matters: This is the backbone of the portal. Without a service catalog, integrations are just disconnected widgets.
What to surface:

• Service ownership
• Tech stack
• Lifecycle stage
• Dependencies
• Links to docs, dashboards, repos, runbooks

7) Documentation and knowledge base

Examples: Confluence, Notion, Git-based docs, Google Docs, MkDocs/Docusaurus
Why it matters: Portals are most useful when they reduce context switching.
What to surface:

• Runbooks
• Architecture docs
• API docs
• ADRs
• Onboarding guides

8) Ticketing and work tracking

Examples: Jira, Linear, Azure Boards, GitHub Issues
Why it matters: Teams often need to connect services with engineering work and operational tasks.
What to surface:

• Open epics/issues tied to a service
• Change requests
• Maintenance tasks
• Incident follow-ups
• Ownership-routing from tickets to teams

9) Identity and access management

Examples: Okta, Azure AD/Entra ID, Google Workspace, LDAP
Why it matters: A portal needs auth, group membership, and permission-aware views.
What to surface:

• Team membership
• SSO and RBAC
• Approval workflows
• Access request routing
• Ownership based on groups

10) Secrets / config / platform developer workflows

Examples: Vault, AWS Secrets Manager, ConfigCat, LaunchDarkly
Why it matters: Useful for operations and release management, though often more advanced.
What to surface:

• Feature flag state
• Config ownership
• Secret rotation workflows
• Environment-specific settings

---

The “must-have” starting set

If you’re trying to prioritize, I’d usually start with:

1. SCM (GitHub/GitLab)
2. CI/CD
3. Observability
4. Service catalog
5. Incident/on-call
6. Docs
7. Identity/SSO

That combination covers the main developer portal jobs:

• Find the service
• Understand ownership and docs
• See status and health
• Act on deploys/incidents
• Navigate to source of truth quickly

---

What matters most depends on your primary use case

If your goal is developer productivity

Prioritize:

• SCM
• Docs
• Service catalog
• CI/CD
• Search across assets

If your goal is platform operations

Prioritize:

• Kubernetes/cloud
• CI/CD
• Observability
• Incident management
• Access/identity

If your goal is governance/compliance

Prioritize:

• Service catalog
• Identity/IAM
• Ticketing/change management
• Repo metadata
• Audit trails

If your goal is onboarding

Prioritize:

• Service catalog
• Docs
• Ownership/team info
• SCM
• Environment/deployment context

---

Integration quality matters as much as breadth

A portal is only as good as the quality of the data behind it. High-value integrations should support:

• Reliable ownership mapping
• Searchable metadata
• Permission-aware access
• Near-real-time status
• Deep links back to source tools
• Automated sync, not manual updates

---

A practical roadmap

Phase 1: foundation

• GitHub/GitLab
• CI/CD
• Service catalog
• SSO/identity

Phase 2: operational value

• Observability
• PagerDuty/Opsgenie
• Kubernetes/cloud

Phase 3: workflow expansion

• Jira/Linear
• Docs/knowledge base
• Feature flags/config
• Cost tools

---

A good rule of thumb

If an integration helps answer one of these questions, it’s likely valuable:

• What service is this?
• Who owns it?
• Where is the code?
• Is it healthy?
• How do I deploy it?
• What’s broken right now?
• Where are the docs/runbooks?
• What work is in flight?
• Who should I contact?

If you want, I can also give you:

1. a prioritized integration matrix by persona (developer, SRE, manager, platform team), or
2. a recommended MVP integration stack for a portal like Backstage.