How to run an API management RFP with these questions
Use these questions to compare build, partner and managed options against one written scope, and ask every bidder for evidence rather than assurances. If your organization needs an API gateway that runs inside its own cloud accounts, data centers or air-gapped network, the choice is usually between operating Apache APISIX or Kong Gateway with your own team, engaging a partner to run it, or buying a managed platform that keeps the control plane outside your environment. The questions below do not favor any of these. Ask each respondent to answer against the same written scope: the APIs in scope, traffic patterns, identity provider, deployment mode, and where the control plane must sit. Answers that cannot be tied to that scope should be treated as marketing.
Ask for artifacts you can inspect. For deployment, request the sample configuration for the chosen mode (traditional, decoupled or standalone for APISIX; traditional, DB-less or hybrid for Kong), the runbook for node replacement and certificate rotation, and the Git repository layout for gateway configuration. For authentication, ask for the exact plugin configuration (for example, the openid-connect settings on APISIX or the Enterprise OpenID Connect plugin on Kong) and a working test showing token validation against your identity provider. Confirm which plugins are open source and which carry an Enterprise license, because that changes both license cost and what the partner can legally deploy. For API inventory and OWASP API Security Top 10 testing, request a sample inventory export and a test report that separates what the gateway enforces from what remains a fix in the application.
Pricing should be requested as a written quote that follows from the agreed scope. DeployOpen does not publish a price list, and it does not estimate fees before scope is fixed, so compare responses by what each one includes: one-time implementation, recurring infrastructure and operations, license fees for any Enterprise components, and upgrade support. Ask each bidder to state which costs recur, what would raise them (more APIs, more regions, more partners, more plugins), and how gateway upgrades and version support are handled. Confirm current version support dates with the vendor before signing, since support windows change.
Which questions to ask about deployment, identity, inventory and testing
Which deployment topology should we choose for APISIX or Kong, and where does the control plane live?
The right topology depends on how many gateway nodes you run, where they sit and who must be able to change routes. Apache APISIX offers traditional mode (data and control plane together), decoupled mode (separate data plane and control plane sharing one etcd cluster) and standalone mode (no etcd, configuration loaded from a YAML or JSON file or an API). Kong Gateway documents traditional mode with a database, DB-less mode with configuration in memory, and hybrid mode with separate control and data planes. A good answer names one topology per environment, explains where the control plane runs and who can reach its Admin API, and states how a data plane behaves if the control plane is unavailable. Ask for a reference diagram showing ports, network zones and the etcd or database placement, along with the backup and restore procedure for that store.
How does the authentication plugin connect to our identity provider?
The gateway validates tokens or delegates login through a plugin, and the partner should show which flow each API class uses. APISIX's openid-connect plugin works with providers such as Keycloak, Auth0, Microsoft Entra ID, Google and Okta, and supports authorization code, client credentials, token introspection and PKCE. In Kong, the OpenID Connect plugin is an Enterprise tier plugin and is not part of the open source gateway, so an open source Kong design needs JWT or OAuth handling built differently and a clear licensing decision. A strong answer maps each client type to a flow, states where signing keys are cached and how they rotate, and explains how scopes reach the upstream service. Request a test matrix covering valid, expired, wrong-audience and revoked tokens, and the configuration files that hold the provider settings.
How will the partner build and maintain an inventory of our APIs?
Inventory is the starting point for every other control, because an API that is not known cannot be rate limited or tested. A capable partner combines a discovery pass over existing gateway routes, load balancer and ingress configuration, and service catalogs, then reconciles that list with owners and business purpose. The answer should describe how new routes must be registered before they are published, whether that is a required field in the route definition or a pipeline check, and how unused or shadow endpoints are flagged. Ask for the inventory schema, the owner of each field, and a sample report from a comparable estate. Confirm whether the inventory is generated from gateway configuration or maintained by hand, since manual lists drift quickly.
How is gateway configuration kept in Git and reviewed before it reaches production?
Configuration should live in version control so every route, plugin and consumer change has an author, a reviewer and a history. With APISIX standalone mode, the gateway reads conf/apisix.yaml or conf/apisix.json and checks for changes every second, so the file in Git can become the single source of truth, applied through a pipeline. With Kong, DB-less or declarative configuration serves the same purpose, while hybrid deployments need a clear rule about which changes come from Git and which from the control plane. A good answer describes the branch model, required pull request reviews, automated linting and schema checks, and how secrets are kept out of the repository. Ask to see a sample pull request, the rollback procedure, and the drift detection that compares the running gateway with the repository.
How will the partner test our gateway against the OWASP API Security Top 10?
The gateway enforces some OWASP API risks and cannot enforce others, so the partner should split the test plan along that line. Authentication, rate limiting, schema validation and access logging can be checked at the gateway, while object-level authorization and business logic flaws remain in the application and need application testing. A strong answer names the OWASP API Security Top 10 2023 categories in scope, the tools and test cases for each, and which findings are expected to be fixed in the upstream service. DeployOpen runs security testing for applications and APIs, so a test plan can cover both layers, but the scope is agreed in writing. Ask for a sample test report, the retest process after fixes, and a list of risks the partner considers out of gateway reach.
How are gateway upgrades rolled out, and which Kong versions are supported on which dates?
Upgrades should follow a tested path: a staging environment that mirrors production, a canary or rolling change across data plane nodes, and a rollback plan that keeps the previous version available. For Kong, the version support policy lists Kong Gateway Enterprise 3.16 as the latest release, released September 15, 2026, with 3.10 and 3.14 as LTS releases supported until March 31, 2028 and April 7, 2029. Kong Gateway 3.9 reached end of full support on December 12, 2025 and reaches end of sunset support on December 12, 2026, so any 3.9 estate needs a plan before that date. For APISIX, the downloads page shows 3.19.0 released on September 28, 2026 and does not mark any release as long-term support, so confirm the support horizon with the vendor. Ask for the written upgrade runbook, the test evidence from the last upgrade and the schedule for security patches.
What does an API management engagement cost, and what drives the price?
Cost has four components: infrastructure in your cloud accounts or data centers, the software licenses that apply to your chosen edition, the implementation work, and ongoing operations. APISIX and the open source Kong gateway carry no license fee for the core product, but enterprise features such as Kong's OpenID Connect plugin and Konnect control plane fall under separate commercial terms. Implementation effort rises with the number of APIs, identity integrations, custom plugins and partner onboarding flows. Recurring costs include gateway compute, etcd or database operations, patching, upgrades and testing retainers. DeployOpen does not publish a price list. Engagements are fixed-scope, so ask for a written scope listing APIs, identity providers, environments and deliverables, and a quote that separates one-time work from recurring support.
Can our own platform team run this gateway after the partner hands it over?
Yes, if the handover is designed for it, and the answer depends on the team's skills and the documentation delivered. Your engineers need to operate the data plane, control plane, identity integration and pipeline, and they need a runbook for each routine change. A good answer lists the artifacts handed over: architecture diagrams, configuration repository access, runbooks for upgrades and rollback, alert definitions and training sessions. It should also state what remains with the partner under a retainer, such as continuous testing or upgrade execution. Ask for the handover checklist, the names of the roles that will receive training, and a clear split of responsibilities for on-call and incident response.
Answers that should worry you in an API management RFP
A partner's answers to the basic architecture and security questions tell you more than a feature list. The cards below cover the answers that should prompt a follow-up before you shortlist anyone. Each one names the answer to listen for and the question to ask next.
No deployment mode or control plane location
If a partner cannot say whether APISIX or Kong will run in traditional, decoupled, standalone, DB-less or hybrid mode, the design is not finished. Where the control plane runs decides who can change routes and plugins, and whether a data plane keeps serving traffic when the control plane is down. Ask for the mode, the port layout, the location of etcd or the Kong database, and the network path from each data plane to the control plane.
Claims of object-level authorization at the gateway
A gateway cannot decide whether a given user may read a given record. That check depends on business data inside the application. A partner who says the gateway enforces object-level authorization is either describing something narrower, such as scope checks, or overstating what the product does. Ask which checks run at the gateway, which stay in the service, and how the partner tests the second group.
Enterprise-only plugins presented as open source
Some capabilities that buyers expect from a gateway are not in the open source edition. For Kong, the OpenID Connect plugin is an Enterprise tier plugin, so a design that assumes it in the open source gateway will need a license. Ask the partner to list every plugin in the design, mark each as open source or commercial, and state who pays for each license and whether that cost recurs.
No plan for configuration drift or Git rollback
If gateway routes, plugins and consumers are edited in a web console or through ad hoc API calls, no one can say what production runs or how to return to a known state. Ask how configuration is stored in Git, how changes are reviewed and promoted, how the running state is compared with the repository, and how a bad change is reverted. A clear answer names the file or declarative source of truth and the pipeline that applies it.
No method for inventorying undocumented APIs
Most organizations have APIs that no one registered, and a gateway only sees traffic that passes through it. A partner who proposes routing everything through the gateway without discovering what already exists will leave shadow APIs outside the controls. Ask how the partner finds APIs from gateway logs, network data and code repositories, how newly found APIs are assigned an owner, and how the inventory is kept current.
Fixed upgrade cadence without a written procedure
A promise to upgrade on a set schedule says little about safety. Gateway versions differ in support status, and Kong Gateway 3.9 has moved into sunset support, so the support window matters as much as the date. Ask for a written rollout procedure covering staging, canary traffic, health checks, the rollback trigger and the time to restore the previous version, along with the support status of each version in scope.
How authentication plugins connect to your identity provider
In an OIDC setup, the gateway sits between clients and your identity provider and handles the protocol steps so that backend services receive only validated identities. With the authorization code flow, a user signs in at the IdP and the gateway exchanges the code for tokens; PKCE protects that exchange for public clients such as single-page apps and mobile apps. With the client credentials flow, a service or partner system authenticates as itself. Token introspection lets the gateway ask the IdP whether an opaque token is still active. The APISIX openid-connect plugin supports these flows, and the Kong OpenID Connect plugin is an Enterprise tier feature, so the gateway choice changes what you can deploy under open source terms. Confirm the exact flow and plugin support against the current documentation for the version you plan to run.
The partner should document five things before build starts. First, client registration: which clients exist in the IdP, their redirect URIs, grant types and who approves changes. Second, token validation: which issuer, audience, signature keys and expiry checks the gateway enforces, and how key rotation is handled. Third, scope mapping: how IdP scopes or group claims map to routes, consumers or plugin decisions, and who owns that mapping. Fourth, session handling: cookie settings, token lifetimes, refresh behavior and what happens at logout. Fifth, secret storage: where client secrets and signing material live, who can read them and how they are rotated. Ask for each item in writing, because it differs by IdP. Keycloak, Microsoft Entra ID, Okta, Auth0 and Google each expose claims and token settings differently.
Ask the partner to run a working flow test against your own IdP in a non-production environment before accepting the design. The test should show a real sign-in through the authorization code flow, a service token obtained through client credentials, an expired or revoked token rejected, and a token with the wrong audience or scope denied. Ask for the captured results and the configuration committed to version control, so you can repeat the test after upgrades. A flow that works only in a vendor demo tenant is not evidence for your environment.
How scoring differs for build, partner and managed platform answers
When your own team operates Apache APISIX or Kong Gateway, the partner is judged on how well they hand over a system you can run. Weight questions about deployment mode, configuration management in Git, and upgrade procedure most heavily, because those determine your long-term operating burden. Open source licensing also matters: APISIX is Apache-2.0 licensed, while Kong's OpenID Connect plugin is an Enterprise tier plugin, so answers that assume it is free in the open source gateway need correction.
- Deployment mode choice: Expect a stated reason for traditional, decoupled or standalone mode for APISIX, or traditional, DB-less or hybrid for Kong, tied to your availability and change control needs.
- Runbooks and handover: Demand written runbooks for certificate rotation, node replacement and Admin API access, plus training for your staff.
- Git repository access: Request read access to the configuration repository during the engagement so you can verify routes, plugins and consumers are versioned.
- Upgrade records: Ask for a worked example of a past minor-version upgrade, including the rollback step.
- Disqualifying answers: Any plan where configuration lives only in an admin console, or where the partner keeps the only copy of the runbooks.
Check that the partner names the exact edition and plugin set they will deploy before you score the rest.
When a partner operates the gateway inside your cloud account or data center, the contract and access model carry most of the weight. Score questions about who holds administrator credentials, how on-call escalation works, and how the partner proves security testing results. The partner should be able to show that the gateway is yours in practice: you own the accounts, the keys and the configuration history, even when they run daily operations.
- Access and credentials: Expect break-glass procedures, named operator accounts, and a documented process for revoking partner access at the end of the engagement.
- Test reports: Request OWASP API Security Top 10 test reports for the gateway and its plugin configuration, with findings and retest results rather than summary claims.
- Configuration in Git: Confirm you hold the repository and the commit history, not only a deployed copy.
- Operational evidence: Ask for sample incident records and change tickets from comparable engagements, anonymized as needed.
- Disqualifying answers: Refusal to hand over configuration, runbooks or test reports at exit, or operations that depend on tools only the partner can access.
Confirm in writing which party is responsible for each control described in your evidence requests.
When a vendor's managed platform runs the gateway, much of the operational evidence sits with the vendor, so your scoring shifts to what they will disclose and where data is processed. Weight questions about data location, audit log export, and the vendor's own security testing and change management. Pricing and per-call scaling are scored in a separate evaluation, so focus here on control and evidence. Ask whether the control plane and the data plane sit in your chosen region and what leaves your environment.
- Data residency and control plane location: Get a written statement of where configuration, logs and traffic metadata are stored and processed.
- Log export: Confirm you can export access and administrative logs to your own storage in a usable format.
- Vendor evidence: Request the vendor's own penetration test summaries and remediation process, and confirm what you can review under NDA.
- Change and upgrade notices: Ask how gateway upgrades are announced, staged and rolled back, and what notice period applies.
- Disqualifying answers: Inability to state where data is processed, or no way to export configuration if you leave.
Since you cannot inspect the platform's internals, make sure every compliance claim is backed by a contract clause or an independent report you can read.
How to score partner responses against the question areas
This table sets out each API management question area with its weight, the evidence a partner should provide, and what a strong and a weak answer looks like. Score each area as pass, partial or fail, and treat a weak answer in deployment, identity or OWASP testing as a stop point until the partner resolves it in writing.
| Question area | Weight | Evidence required | Strong answer | Weak answer |
|---|---|---|---|---|
| Deployment and control plane | High | Chosen mode (traditional, decoupled, standalone for APISIX; traditional, DB-less or hybrid for Kong), network diagram, admin API exposure plan | Names the mode, explains why it fits your data center or cloud layout, and restricts the Admin API port to a management network | Offers one generic architecture without naming the mode or where the control plane runs |
| Identity integration | High | Plugin configuration for your IdP, supported OAuth or OIDC flows, token validation and claim mapping samples | Shows how the openid-connect plugin or equivalent connects to your provider, with flows chosen per client type and tested token validation | Says the gateway supports SSO in general, with no flow list, no client types and no test evidence |
| API inventory | High | Discovery method, sample inventory export, ownership fields and process for undocumented APIs | Describes how routes are reconciled with a source of truth, assigns owners and flags APIs with no owner or no current spec | Relies on a manual spreadsheet with no reconciliation step or no owner field |
| Git-managed configuration | Medium | Repository layout, review and merge process, sample declarative config, drift detection approach | Keeps routes, plugins and consumers in version control with reviewed merges and detects drift between Git and the running gateway | Keeps changes in the admin console or describes Git only as a future option |
| OWASP API testing | High | Test scope, mapping of each OWASP API Security Top 10 2023 risk to a control or test, sample findings report | Maps each risk to what the gateway enforces and what the application must enforce, and states which risks need application-level testing | Claims full OWASP coverage from gateway plugins alone or omits object-level authorization |
| Upgrades and rollback | Medium | Version policy, release channel used, staging promotion steps, documented rollback test | Names the release line and support status, promotes through staging with config tests, and rehearses rollback before go-live | Commits to upgrading to latest without a staging path or a rollback procedure |
| Support model | Medium | Support hours, escalation path, named roles, patch cadence and retainer scope in writing | Defines response paths, on-call coverage and what is included in a retainer, with terms agreed in the written scope | Quotes support in general terms with no written escalation path or scope boundaries |
What to ask about testing the OWASP API risks
A good answer maps each risk in the OWASP API Security Top 10 2023 to the layer that actually controls it. The gateway can enforce authentication at the edge, rate limits and quotas per consumer, and schema validation of request bodies and parameters. Object-level authorization and business logic stay in the application, because the gateway cannot know whether consumer A may read record B. Ask the partner to produce this mapping as a written table for your API estate before testing starts, and to mark each risk as gateway-enforced, application-enforced, or shared. A partner that claims the gateway covers the whole list should be asked to show the configuration that does it.
Next, ask how the partner tests both layers and what scope each test covers. For the gateway, ask which checks run against the live route definitions and plugin configuration, such as whether limit-count or equivalent rate limits apply to every consumer group, and whether requests bypassing the gateway are blocked at the network level. For the application, ask whether testing includes authenticated sessions for at least two roles, which is the only practical way to find broken object-level authorization. Ask which tools they use, whether testing is manual, automated or both, and whether the scope is agreed in writing with a named list of endpoints and environments. Confirm that production testing is allowed and under what change controls.
Finally, ask how findings are tracked and how retests are evidenced. Request the severity model, the ticketing system where findings land, the owner for each fix (gateway team or application team), and the criteria for closing a finding. A retest report should name the original finding, the evidence that the fix works, and the date of the retest. DeployOpen runs application and API security testing as a service, so ask us to show how a scope, findings register and retest evidence would be structured for your estate, and confirm with any partner what they will hand over at the end of each cycle.
How gateway upgrades should be rolled out and proven
A good upgrade sequence confirms the version line and its support dates before any change, proves the new release against the same configuration that runs in production, and leaves a documented path back. The result is a gateway upgrade that partners and auditors can trace from request to change record.
Confirm the version line and support dates
Before any work starts, the partner should establish which release line the organization runs and which target version it moves to. For Kong Gateway, check the Kong Gateway version support policy, which lists end of full support and end of sunset support dates for each line, and note that the policy applies to Kong Gateway Enterprise. For Apache APISIX, check the release notes and the downloads page, which does not mark any release as long-term support. The output is a written decision record naming the current version, the target version and the support deadline that drives the timing. Ask the partner to show that record before scheduling the change.
Build staging from the same Git configuration
The partner builds a staging gateway from the exact commit of routes, plugins, upstreams and consumer definitions that production runs, deployed in the same topology as production. For APISIX this means the same deployment mode, whether traditional, decoupled or standalone, and for Kong the same topology, whether traditional, DB-less or hybrid. Staging should use the same identity provider integration and the same certificates pattern, with test credentials. The check that closes this step is a configuration diff showing that staging and production differ only in environment-specific values such as hostnames and secrets references.
Run the upgrade in staging and record results
The partner performs the upgrade on staging using the same runbook that will be used in production, so that any manual step surfaces early. They record the version applied, any migration output, configuration warnings and changed default behavior, and they confirm that the gateway starts and reports healthy on its admin and data endpoints. Any deprecated plugin option or changed schema is fixed in Git, not on the running node. The output is a staging upgrade log attached to the change ticket, which the reader can ask to see.
Run regression on routes and plugins
The partner runs an automated regression suite that sends known requests through every critical route and checks status codes, response bodies, headers, authentication outcomes and rate limit behavior. It covers each authentication plugin in use, including token validation against the identity provider, and each traffic control and observability plugin. Negative tests should confirm that unauthenticated and over-limit requests are still rejected. The check that closes this step is a pass report with no unexplained differences from the pre-upgrade baseline, and any accepted difference is signed off by the API owner.
Roll out by node or region
The partner moves production in stages, starting with a small set of nodes or one region, then expanding once health checks, error rates and latency stay within the baseline agreed with the operations team. In a hybrid or decoupled design, data plane nodes can be upgraded separately from the control plane where the vendor documentation allows that order, so the team should confirm the supported sequence for their version. The partner watches dashboards and logs during each stage and pauses if a threshold is crossed. The output is a stage log showing which nodes moved and when, with the observed results.
Keep a tested rollback path
Before the first production node changes, the partner documents how to return each node to the previous version and the configuration state it needs. Because configuration lives in Git, rollback usually means reverting to the last known good commit and redeploying the prior release, but the team should prove this on staging before relying on it. The runbook names the owner who can call the rollback and the signals that trigger it. The check that closes this step is a rehearsal record showing that the rollback restored the previous version and that the regression suite passed afterward.
Record the change and the evidence
The partner closes the change by recording the versions before and after, the commit identifiers, the regression results, the staged rollout log, any rollback events and the approvals. This record links to the support policy or release notes used to set the timing, so the reasoning for the upgrade is traceable. The organization keeps the record in its own change management system or Git repository. The output is a single change package that the internal audit or security team can review without asking the partner to reconstruct events.
How API inventory and Git-managed configuration should work together
Ask any partner how they will build your API inventory, and the answer should combine two sources: the gateway's own configuration and a discovery pass over live traffic. Routes, upstreams, consumers and plugins in the gateway describe the APIs you have published through it. They say nothing about the internal services that bypass the gateway, the old endpoints still receiving calls from a partner, or the shadow APIs that a team exposed directly. Ask the partner which discovery method they will use, whether it reads gateway access logs, service mesh telemetry or network flows, and how newly found endpoints are assigned an owner and a classification. An inventory built from only one source will look complete and still miss the APIs that carry the most risk.
Routes, plugins and upstreams belong in version control for the same reason application code does: every change needs an author, a reviewer and a history you can roll back. In a file-driven APISIX deployment, the conf/apisix.yaml file is the configuration itself, so the repository can hold the exact state the data plane loads. In Kong's DB-less or declarative setups, the equivalent is a declarative configuration file. Ask the partner to show a merge request that changes an authentication plugin, and to show the automated checks that run before it merges, such as schema validation, linting of route definitions, and a policy test that confirms protected routes still require authentication. Also confirm whether secrets are kept out of the repository and injected from a vault.
Two questions separate a workable design from a fragile one. First, how is drift between Git and the running gateway detected and corrected? Ask for the reconciliation job, its schedule, the alert it raises when a live route differs from the repository, and whether the correction is automatic or requires an approved change. Manual edits made through the Admin API should be either blocked or reported. Second, who holds the repository after handover? Agree in writing that your organization owns the repository, the CI pipeline definitions and the deployment credentials, that all branches and history transfer to you, and that the partner's access ends on a stated date. If the repository lives in your own Git server or hosted account from day one, this question becomes a checklist item rather than a negotiation.
How DeployOpen scopes, delivers and supports API management engagements
DeployOpen plans, implements, hardens, documents and supports self-hosted open-source gateways inside the client's own infrastructure. For API management RFP questions, we start with a written scope that answers each question against your estate, then deliver and hand over the evidence your evaluators ask for.
How we scope
- Inventory your APIs, consumers, traffic patterns and identity provider before naming a gateway deployment mode
- Agree in writing which RFP questions the engagement answers and which remain with your vendor or internal teams
- Confirm where the control plane runs, who holds Admin API access and which environments are in scope
- Engagements are fixed-scope, so deliverables and timelines are agreed in writing before work starts
How we build
- Deploy APISIX or Kong data and control planes in your cloud accounts, data centers or air-gapped network
- Connect authentication plugins to your identity provider and test each supported OAuth or OIDC flow end to end
- Keep gateway routes, plugins and policies in Git with reviewed changes and environment-specific configuration
- Test the gateway and the APIs behind it against the OWASP API Security Top 10 and document what each control covers
How we hand over
- Deliver a written API inventory with owners, versions, exposure level and the authentication method each API uses
- Provide runbooks for backup, restore, upgrade rollout and rollback, tested on your staging environment
- Document which risks the gateway enforces and which must remain in application code, with the evidence for each
- Map the configuration and logging evidence to the controls your assessors or auditors will request
How we support
- Offer ongoing support, upgrades and continuous testing as retainers after the initial handover
- Track upstream release lines and advise on upgrades, including license and version support status for Kong and APISIX
- Re-run security testing after material changes to routes, plugins or identity integration
- Confirm retainer scope, response expectations and upgrade cadence in writing before the retainer starts

