Advanced Kong Interview Questions: Architect Level (2027)

44 advanced Kong interview questions for architects: hybrid mode, incremental sync, plugin priority, custom plugins, expressions router, multi-region.

Oct 1, 2025 - 11:16
Nov 11, 2026 - 00:19
 0  99
Advanced Kong Interview Questions: Architect Level (2027)

Advanced Kong interview questions test whether you can design a gateway platform, not just configure one. Expect questions on hybrid mode control and data planes, DB-less and decK, plugin priority and dynamic ordering, custom plugin design, the expressions router, Kubernetes Gateway API, multi-region scaling and Admin API security. This page has 44 architect-level questions with direct answers.

It is written for engineers moving into gateway architect or platform lead roles. If you need the full topic list first, start with our main Kong API Gateway interview questions and answers. Facts below were checked against Kong's developer documentation in November 2026.

Key takeaways

  • Architect rounds ask "why" and "what breaks", so every answer should name a trade-off and a failure mode.
  • Hybrid mode is the default design for multi-region Kong: one control plane, many DB-less data planes on port 8005 for config and 8006 for telemetry.
  • Incremental config sync (incremental_sync = on) sends only changed entities, but it needs CP and DP on the same version and changes how custom plugin caches behave.
  • Plugin order is set by static priority (for example bot-detection 2500, cors 2000, key-auth 1250, rate-limiting 910). Enterprise dynamic ordering can change it per instance.
  • The expressions router with an explicit priority is the tool for large, overlapping route sets.
  • Admin API exposure, secret handling and CP certificate design are the security questions you are most likely to get.

How this page differs from the other Kong posts

Each Kong post on this blog has its own job. Use this table to pick the right one.

PostFocusBest for
Kong API Gateway interview questionsAll core topics, 80 Q&AsEveryone, start here
75+ Kong interview questions: hands-on configCommands, Admin API calls, YAMLFreshers and lab practice
Kong engineer interview questionsDay-to-day operations and troubleshooting2 to 5 years
Kong interview prep guide4-week study planStructured preparation
This pageArchitecture, internals, trade-offsSenior, lead and architect roles

Foundations an architect is still asked about (questions 1 to 8)

Senior candidates get a few warm-up questions, but the interviewer wants the reasoning behind each design, not a definition.

1. Why does Kong separate Services, Routes and Upstreams instead of using one object?

Because each changes at a different rate and is owned by different people. A Route describes how clients reach an API (hosts, paths, methods, headers). A Service describes the backend. An Upstream with Targets describes load balancing across backend instances. Splitting them lets a team add a new path, move a backend or add an instance without touching the other two objects, and lets plugins attach at the level where a policy belongs.

2. What is the cost of putting a gateway in front of every service?

Added latency per hop, one more component that can fail, and a shared config that many teams can break. An architect answers this by naming the controls: the X-Kong-Proxy-Latency and X-Kong-Upstream-Latency headers to separate gateway time from backend time, horizontal DP scaling with no shared state on the request path, and config ownership split by tags or workspaces.

3. Which three deployment topologies does Kong support, and what decides the choice?

Traditional (every node reads a database), DB-less (each node loads a declarative file) and hybrid (a control plane with a database pushes config to DB-less data planes). The deciding factors are where the database can live, how many regions you run, whether teams change config through the Admin API at runtime, and whether you want data planes with no database credentials at all.

4. Why is DB-less mode attractive for immutable infrastructure?

The whole configuration is a file you can version, review and bake into a release. Nodes have no database dependency, so they start fast and scale out simply. The trade-off is that the Admin API is read-only for entities and plugins that need to write state to a database at runtime do not work, so you check plugin compatibility before choosing it.

5. Where does decK fit in an architecture?

decK is the tool that turns Kong config into files and applies files back to Kong. It works against traditional and hybrid control planes and against Konnect. In a platform design it is the bridge between Git and the gateway: deck gateway diff in pull requests, deck gateway sync on merge, and --select-tag so each team only manages its own entities.

6. What is the difference between plugin scope precedence and plugin execution order?

Precedence decides which configured instance of the same plugin runs when it exists at several scopes; the most specific (for example Consumer plus Route plus Service) wins and only one runs. Execution order decides which different plugins run first within a phase; that is priority. Candidates often mix them up, so state both in one breath.

7. Why can a global plugin run in the rewrite phase but a Route plugin cannot?

Rewrite runs before Kong has matched the request to a Route or Service. At that point Kong does not know which scoped plugins apply, so only global plugins execute there. Anything that depends on the Route must wait for access.

8. How does Kong Mesh relate to Kong Gateway?

Kong Gateway handles north-south traffic at the edge. Kong Mesh is Kong's service mesh, built on the CNCF Kuma project, and handles east-west traffic between services with sidecars or Kuma's data plane proxies. An architect explains where each policy belongs: client authentication and quotas at the gateway, mTLS and retries between services in the mesh.

Design questions for 2 to 5 years (questions 9 to 22)

9. Walk through the hybrid mode connection between CP and DP.

The DP opens an outbound connection to the CP's cluster_listen address (default port 8005) and sends telemetry to cluster_telemetry_listen (default 8006). Konnect uses 443 for both. Both sides authenticate with mutual TLS using cluster_mtls = shared or pki. The CP pushes config down this connection; the DP stores it in a local LMDB cache.

role = data_plane
database = off
cluster_control_plane = cp.internal.example:8005
cluster_telemetry_endpoint = cp.internal.example:8006
cluster_mtls = pki
cluster_cert = /etc/kong/dp.crt
cluster_cert_key = /etc/kong/dp.key
cluster_ca_cert = /etc/kong/ca.crt

10. Why is an outbound DP connection a good design for network security?

Data planes in remote networks or clouds only need egress to the CP. You do not open inbound ports into each environment, and DPs never hold database credentials. If one DP is compromised, the attacker gets that node's cached config and certificate, not write access to the cluster, especially when each DP has its own PKI certificate that you can revoke.

11. What is incremental config sync and when would you turn it on?

With incremental_sync = on on both CP and DP, the CP sends only changed entities instead of the full config on every change. It helps clusters with large configs or frequent changes, where full pushes waste bandwidth and CPU. Kong's docs list conditions: CP and DP must run the same version, a newer CP silently falls back to full sync, a newer DP is rejected, and more than 512 changes during a disconnect triggers a full sync anyway.

12. What can break when you enable incremental sync?

Three things, per Kong's docs. Custom plugins that cache entities must register CRUD event handlers and invalidate their cache, or they serve stale data. The local rate-limiting strategy is not recommended because rapid updates can reset counters. Writing directly to the database, outside the Admin API, decK or Terraform, can make DPs miss updates and return 404 for valid Routes. You can roll back by setting it to off on a DP without a restart.

13. What are the version rules between CP and DP, and how do they shape an upgrade plan?

For self-managed hybrid mode the CP accepts DPs on the same major version and newer patch versions, but rejects DPs on a newer minor version. Plugin major versions must match too. Dedicated Cloud Gateways in Konnect need the exact same version. So the plan is: upgrade the CP first, then roll DPs region by region, and never let a DP image run ahead of the CP.

14. How would you bring up a new DP while the CP is down?

Copy dbless.lmdb from a healthy DP, or start the node with a declarative config file. Kong's hybrid mode docs describe both. Plan this before an incident: keep a recent export of config in your artifact store so scaling out does not depend on CP availability.

15. What does the static plugin priority mean in practice?

Within a phase, plugins with higher priority run first. In Kong 3.16 the bundled values include correlation-id 100001, bot-detection 2500, cors 2000, jwt 1450, oauth2 1400, key-auth 1250, openid-connect 1050, ip-restriction 990, request-size-limiting 951, acl 950, rate-limiting 910, request-transformer 801, proxy-cache 100, prometheus 13 and http-log 12. That is why authentication runs before ACL and rate limiting by default.

16. When would you change the default order with dynamic ordering?

Dynamic ordering is an Enterprise feature that sets an ordering option on a plugin instance to run before or after other plugins in the access phase. A common case is running rate limiting before authentication to shed a flood of unauthenticated requests cheaply, especially when the auth plugin calls an external identity provider. The cost is that limits then apply per IP or globally instead of per consumer.

plugins:
- name: rate-limiting-advanced
  ordering:
    before:
      access:
      - openid-connect
  config:
    limit: [100]
    window_size: [60]

17. How do you pick a PRIORITY for a custom plugin?

Decide which bundled plugins must run before and after it, then pick a number between their priorities. A plugin that reads the authenticated consumer must sit below the auth plugins (below 1050 if you support openid-connect). A plugin that rejects requests by header before anything expensive runs should sit above them. Document the number, because two plugins with the same priority have no guaranteed order.

18. Lua, Go, JavaScript or Python for a custom plugin?

Lua runs inside the Nginx worker with the PDK and has the lowest overhead, so it is the default choice for anything on the hot path. Kong also offers plugin servers for Go, JavaScript and Python, which run as separate processes and talk to Kong over RPC. They suit teams without Lua skills or plugins that reuse existing libraries, at the cost of extra latency and another process to manage.

19. Why would you choose the expressions router?

With router_flavor = expressions you write Routes as predicates such as http.path ^= "/foo/bar" combined with logical operators, and you set an integer priority that decides evaluation order (higher first). It gives exact control when many teams publish overlapping paths, where the traditional router's implicit ordering rules become hard to reason about. Same-priority Routes have undefined order, so a priority scheme is part of the design.

routes:
- name: orders-v2
  expression: 'http.path ^= "/orders" && http.headers.x_api_version == "2"'
  priority: 200

20. Ingress or Gateway API on Kubernetes, from an architect's view?

Gateway API separates roles: platform teams own GatewayClass and Gateway, app teams own HTTPRoute. That maps well to a shared Kong platform. Kong's docs state KIC 3.5 and later conform to Gateway API v1.3. Plugins still attach through KongPlugin or KongClusterPlugin resources referenced by annotation. Ingress remains fine for simple clusters or existing estates.

21. When would you add the Kong Operator to a Kubernetes design?

When you want Gateway resources to provision Kong deployments themselves, for example one gateway per team or per environment managed declaratively, plus resources such as KongLicense. If you run a single shared gateway installed by Helm, KIC alone is often enough.

22. How do you make secrets safe in a GitOps Kong setup?

Store references in config, never values. Kong's Vault entity resolves references such as {vault://env/redis-password} at runtime from environment variables, HashiCorp Vault or cloud secret managers. decK files can then live in Git, and rotation happens in the secret store. Pair this with decK's own environment variable substitution for anything that is not a plugin field.

Senior and architect questions (questions 23 to 36)

23. Design Kong for three regions with one source of truth.

Run one control plane (self-managed with a highly available Postgres, or Konnect) and a pool of DPs per region behind regional load balancers, with DNS or anycast steering clients to the nearest region. Config flows Git, decK, CP, DPs. Use per-region PKI certificates, a regional Redis for any rate-limiting that must be accurate, and dashboards per region. Write down what happens when the CP is unreachable: traffic continues, changes wait.

24. Where can the control plane become a single point of failure, and how do you reduce it?

The CP is not on the request path, so its loss stops changes, not traffic. Risk remains in the database, in certificate expiry and in an upgrade that breaks DP compatibility. Mitigate with a replicated database and tested restore, certificate expiry alerts, multiple CP nodes behind a load balancer, and a config export kept outside the CP.

25. Self-managed CP or Konnect?

Konnect removes CP patching, database operations and upgrades, and adds hosted features such as Dev Portal, observability and Catalog. Self-managed keeps all config inside your network, which some regulated teams require, and avoids depending on an external SaaS for changes. Many designs use Konnect for the CP and self-managed DPs, so traffic stays in your network.

26. How do you design rate limiting that is accurate across 30 nodes?

Local counters are fast but each node counts separately, so a cluster-wide limit is exceeded by up to the node count. Use the redis policy for shared counters, and with rate-limiting-advanced tune sync rate so nodes batch updates. Decide what happens when Redis is down. Explain the latency cost of the Redis call and keep Redis in the same region as the DPs.

27. How would you build multi-tenancy on one Kong cluster?

Separate config ownership with tags and decK --select-tag for open source, or Workspaces and RBAC in Enterprise. Separate consumers and credentials per tenant, apply Consumer Groups for tiered limits, and keep global plugins to a short reviewed list. For hard isolation (different compliance zones), run separate control planes or Konnect control plane groups instead of sharing one.

28. How do you govern plugins across many teams?

Make the platform team own the allowed plugin list in kong.conf, global plugins and priorities. Lint decK files in CI to reject plaintext secrets, missing auth on public Routes and plugins outside the list. Kong provides deck file lint with rulesets for this. Review new custom plugins like application code, including load tests.

29. What does your custom plugin release process look like?

Unit test with Kong's test tooling (Pongo), load test against a staging DP, package the plugin into the DP image, add it to the plugins setting on CP and DPs, and roll out behind a canary DP pool. Version the plugin schema carefully, since the CP rejects plugin major version mismatches with DPs. Keep a rollback image ready.

30. How do you keep a custom plugin from adding latency?

Avoid blocking I/O on the hot path, cache external lookups with kong.cache and invalidate on change, do expensive work in the log phase when the client does not need the result, and use cosockets rather than blocking libraries. Measure with X-Kong-Proxy-Latency before and after.

31. How would you design authentication for partners, mobile apps and internal services?

Partners: key-auth or mTLS with per-partner consumers and limits. Mobile and web users: OpenID Connect against your identity provider, with token validation at the gateway. Internal services: mTLS or short-lived JWTs, ideally handled by the mesh. Put each audience on separate Routes so the auth plugin scope is explicit and the ACL plugin can restrict access by group.

32. How do you secure the Admin API in a design review?

Bind it to localhost or a private interface, never to the internet. Put it behind an internal load balancer with authentication, enable RBAC in Enterprise, and in hybrid mode note that only the CP serves the Admin API. DPs expose a Status API with a few read-only upstream health endpoints. Audit who can run decK against production.

33. How do you harden the path from Kong to the upstream?

Use HTTPS to upstreams with certificate verification turned on, client certificates on the Service where backends require mTLS, and network rules so backends accept traffic only from Kong. Strip client-supplied identity headers with request-transformer before adding your own trusted headers.

34. What observability design would you propose for Kong?

Prometheus metrics scraped from the Status API on each DP for latency, status codes and upstream health; access logs shipped asynchronously with http-log or a log plugin; OpenTelemetry traces with correlation IDs propagated to backends. Alert on 5xx rate per Service, p99 proxy latency, Target health and DP config sync age. Our Prometheus interview questions cover the scraping side.

35. How do you test gateway config before production?

Validate files with deck file validate and lint rules, run deck gateway diff against staging and production in the pull request, apply to a staging CP, then run contract tests through the gateway (auth, limits, routing). For risky changes, sync to a canary DP pool first, possibly a separate control plane.

36. How would you plan an upgrade across an LTS line?

Read the changelog and breaking changes for every minor version you cross, test decK files against the new version, upgrade the CP (traditional mode needs kong migrations up and finish), then roll DPs. Kong's support policy lists LTS releases with longer support, and in November 2026 it named 3.10 and 3.14 as LTS. Production teams usually move from one LTS line to the next.

Scenario questions (questions 37 to 44)

37. After enabling incremental sync, some valid Routes return 404 on a few DPs. What do you check?

First, whether anyone wrote to the database directly; Kong's docs warn this causes skipped updates and 404s. Next, compare DP and CP versions, since a mismatch changes sync behaviour. Check DP logs for sync errors. As an immediate fix, turn incremental sync off on the affected DPs (no restart needed) to force full sync, then remove the direct database writes from the process.

38. A new auth plugin from a vendor runs after rate limiting and lets floods reach your identity provider. Why?

Its priority is lower than rate-limiting's 910, or the other way round, the limits are per consumer and unauthenticated requests are not limited at all. Look at both priorities, then decide: add an IP-based limit at higher priority, use dynamic ordering in Enterprise, or put bot-detection and ip-restriction in front.

39. Two teams publish Routes for /api and /api/orders and traffic goes to the wrong backend after a migration to the expressions router. What happened?

Both Routes probably have the same priority, and same-priority evaluation order is undefined in the expressions router. Assign a priority scheme (more specific paths get higher numbers), enforce it in decK lint rules and test with requests to each path.

40. A region's DPs stopped receiving config after a CP upgrade. Traffic is fine. Next steps?

Check whether the DP image in that region is now on a different minor version or has a plugin version the CP rejects; the CP logs a warning and stops pushing to incompatible DPs. Check cluster certificate validity and that the DP can still reach port 8005. Fix by aligning versions, then confirm sync on the CP's data plane list.

41. Security wants proof that a compromised DP cannot change config. How do you answer?

DPs have no Admin API for writes and no database credentials; config only flows from CP to DP. With cluster_mtls = pki each DP has its own certificate, so you can revoke one, and the LMDB cache can be encrypted with the cluster certificate key. Show the network rules: DPs only need egress to the CP.

42. Kong DPs get OOMKilled after a large tenant onboarded 5,000 Routes. What are your options?

DB-less and hybrid DPs hold the full config in memory, so raise memory limits and mem_cache_size to fit it, reduce duplicate Routes and plugin instances, consider incremental sync to cut push overhead, or split the tenant onto its own control plane and DP pool.

43. Your CP database is lost and there is no recent backup. How do you recover?

Traffic keeps flowing on cached DP config. If decK files in Git are the source of truth, build a new CP and run deck gateway sync. If Git is behind, export what you can: the DP LMDB cache holds the last config. Afterwards, add scheduled database backups and a scheduled deck gateway dump to the runbook.

44. A team asks to run a custom Lua plugin that calls an external API on every request. What do you require before approving it?

A load test showing added latency at expected traffic, caching with invalidation, a timeout and a fallback when the external API is down, a documented priority, and a log-phase design if the result is not needed for the response. If it cannot meet the latency budget, propose moving the logic to the backend or to an async pipeline.

How to prepare for an architect-level Kong round

  • Build a hybrid lab with one CP and two DPs, then stop the CP and confirm traffic continues.
  • Manage everything through decK in Git, with lint rules in CI.
  • Write one small Lua plugin with a chosen priority and test it with Pongo.
  • Draw a multi-region diagram and practise explaining it in five minutes.
  • Run Kong on Kubernetes with Gateway API resources. Our CKA training in Pune (classroom in Kharadi and live online) covers the cluster skills these designs assume.

For wider DevOps design rounds, see our 200+ DevOps interview questions.

FAQ

What does "advanced" mean in a Kong interview?

It usually means design and trade-off questions: hybrid mode, sync behaviour, plugin ordering, custom plugins, multi-region layout, governance and security, rather than definitions and commands.

Do I need Kong Enterprise experience for architect roles?

It helps, because Workspaces, RBAC and dynamic plugin ordering are Enterprise features. You can still prepare with open source Kong and Konnect's free tier, and explain where Enterprise features would change your design.

Which ports matter in hybrid mode?

The control plane listens on 8005 for cluster config and 8006 for telemetry by default. Konnect uses 443 for both. Proxy traffic uses 8000 and 8443.

What is incremental config sync in Kong?

It is a hybrid mode option, set with incremental_sync = on on CP and DPs, that sends only changed entities instead of the full config. It needs matching versions and care with custom plugin caches.

How is plugin execution order decided in Kong?

By each plugin's static priority, highest first within a phase. Kong Gateway Enterprise adds dynamic ordering, which moves a plugin instance before or after others in the access phase.

Should I learn the expressions router?

Yes for senior roles. It gives explicit route priority and predicate matching, which large shared gateways need, and interviewers use it to test routing knowledge.

Which Kong version should I talk about?

Mention the LTS lines in Kong's support policy, 3.10 and 3.14 as of November 2026, and check the policy page before your interview because it changes.

References

What's Your Reaction?

Like Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.