How to build a clear RFP for your developer portal

May 1, 2025

Ready to start?

How to build a clear RFP for your developer portal
Listen to article
00:00 00:00

Internal developer portals (IDPs) have become a key component of platform engineering and SDLC modernization initiatives. They consolidate fragmented toolchains and workflows, wrangle the chaos around technical debt, simplify the measurement of metrics, standardize ownership, and help engineering teams move faster — without central governance teams losing visibility or control.

But figuring out which portal is right for your organization? That’s the hard part.

Your team might be deciding between building in-house, customizing an open-source tool, or working with a vendor. Every option has tradeoffs. A well-written RFP won’t give you all the answers, but it will help you ask the right questions.

Whether you’re evaluating solutions now or planning for later this year, this guide will help you cut through the noise and focus on what’s essential.

{{rfp}}

Why do you need to write a portal RFP?

At its core, an RFP (Request for Proposal) is a tool to align your internal stakeholders, clarify your goals, and avoid building something that solves yesterday’s problems. It’s not just for vendors, either — it is a structured way to answer the questions that matter most:

  • What challenges are you actually trying to solve?
  • What constraints do you need to work within?
  • What does “success” look like for your organization?

At Port, we consider requests for proposals as sort of a stepping stone for new platform teams to unite their stakeholders before the portal comes into play. Platform engineering best practices encourage teams to be clear about their needs, work toward common goals, and be open about when problems occur and how they impact things like developer experience, incident response, and overall delivery quality.

Thinking this way — about team needs first — will help you figure out how to build the best possible proof of concept, which will have a positive correlation with your portal adoption rate.‍

What a good RFP looks like

Not all RFPs are created equal. A well-written RFP doesn’t just list features — it frames your needs clearly, prioritizes what matters, and sets up both your team and your potential vendors for meaningful conversations.

A good RFP is:

  • Focused. It’s not a 30-page document trying to cover every possible future scenario. It zooms in on your current context and needs.
  • Structured. It follows a clear format, making it easy for vendors to respond and for stakeholders to review.
  • Use-case driven. Instead of asking for generic capabilities, it anchors requirements in real workflows and outcomes.
  • Comparative. It gives you a way to evaluate responses side-by-side, based on criteria that matter to your team.
  • Collaborative. It incorporates input from the people who will use, maintain, and support the portal — not just those selecting it.

Most importantly, a good RFP isn’t a formality. It’s a decision-making tool. It helps you avoid buzzword fatigue, cut through sales talk, and understand how a given solution will actually support your engineering organization.

In the next section, we’ll break down exactly what to include — and what to skip.

What to include in your RFP

You don’t need to over-engineer your RFP, but you do need to be intentional. Every section should serve a purpose: to clarify your needs, help vendors respond accurately, and make it easier for you to compare solutions.

Here’s a practical breakdown of what to include:

1. Background and context

  • A short overview of your organization, team structure, and engineering scale
  • Relevant existing tools or systems
  • Key stakeholders and their roles in the decision

2. Goals and challenges

  • What are you hoping to improve or fix?
  • Why now? What’s driving the need for a portal?
  • Have there been internal efforts to solve these problems? If so, why have they not succeeded?
  • Are there any known gaps or pain points you want to prioritize?

3. Success criteria

  • How will you evaluate whether the portal is doing its job?
  • What outcomes matter to you — faster onboarding, better service visibility, improved DORA metrics, fewer escalations?

4. Functional and technical requirements

  • Specific capabilities you need (e.g. a catalog that can accommodate our practices today, as well as those spanning the last two decades of development, Role Based Access Controls that mirror my systems of record, real-time integrations)
  • Clearly articulated must-haves vs. nice-to-have features
  • Compliance, security, scalability, and integration constraints

5. Evaluation process and timeline

  • How and when you plan to review proposals
  • What the selection process will look like
  • Any planned demos, proof of value or stakeholder checkpoints

6. Submission guidelines

  • Who should respond, and how
  • Required formats or templates (if any)
  • Deadline for responses

This structure keeps the focus on real needs, avoids unnecessary overhead, and gives vendors the clarity they need to tailor their proposals effectively.

Considerations when evaluating vendors

Once you’ve received responses to your RFP and your portal initiative progresses, don’t let your evaluation get stuck in a spreadsheet. The best decisions come from real usage, not just comparing the number of ticked checkboxes.

Here’s what to pay attention to:

1. Start with real use cases

Review how well each proposal aligns with the goals and challenges you outlined. Can the solution handle your real tools, workflows, and needs — not just generic ones?

2. Focus on interaction, not just features

The evaluation process is also about working style. How responsive and flexible is the vendor? Are they proactive in scheduling, supportive in communication, and transparent about limitations?

3. Consider how the product “feels”

Polished demos are expected. What matters more is how the product feels in your hands. If possible, ask for a walkthrough based on your actual context.

4. Consider whether the product will grow with you

Imagine a major change in your use cases, tools, org structure or technical architecture in a year’s time. How will the product accommodate your future needs? Will it?

5. Observe the intangibles

How well does the team understand the domain and your priorities? Are they listening, adapting, engaging your team?

The goal isn’t just to pick the tool with the most boxes checked. It’s to choose the one that feels like a partner.

To help you with this process, our ready-made template incorporates these priorities into a structured evaluation process.

Use our RFP template

To make things easier, we’ve put together a customizable RFP template you can use as a starting point. It mirrors the structure outlined above and includes helpful prompts to guide each section.

You can download the template here or duplicate it into your own workspace. It’s designed to be lightweight, editable, and easy to share across teams.

Inside the template, you’ll find:

  • Pre-filled section headers and guidance text
  • Example language you can modify based on your context
  • A clean structure that makes vendor responses easier to compare

Whether you're using it as-is or adapting it to your internal process, the template gives you a head start — and ensures you’re asking the right questions from the beginning.

{{rfp}}

Build the portal that's right for you

A developer portal isn’t just another tool, it’s infrastructure for cultural and technical transformation. Choosing the right one for your needs should be deliberate.

A well-structured RFP helps you:

  • Align your stakeholders around shared goals
  • Surface the real needs driving the project
  • Get clearer, more relevant responses from potential partners
  • Help your team select the right solution

The end result? Faster decisions, better conversations, and a portal that actually addresses the problems you set out to address.

Use the template, tailor it to your needs, and start the process with confidence. And if you want a second pair of eyes on your draft — or just want to chat about your portal plans — we’re happy to help.

{{cta_5}}

Tags:

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