API design

API Development Trends: What Changed and What Lasted

A November 2026 review of the API trends we predicted for 2024: AI, GraphQL federation, edge runtimes, zero trust, OpenAPI tooling and real-time APIs.

By the APIStack team··Updated ·10 min read

Columns of green characters on a dark screen

This article was first published in September 2024 as a list of six trends expected to shape API development. This revision, written in November 2026, goes back through the same six and records what happened to each: which held up, which stalled, and which were described wrongly the first time. It is for developers deciding what to adopt, and the statements about specifications reflect their status as of this revision.

The short version

Prediction in 2024Status in November 2026
AI will generate and run API logicHalf right. AI writes API code; the larger change is AI agents calling APIs
GraphQL federation and streaming will matureFederation is established; @defer and @stream are still not in the specification
APIs will move to edge runtimesPartly reversed. One major platform now steers users back to Node.js
Security will shift to zero trustHeld, though the idea was not new, and the main API risks are still authorization bugs
Interactive docs and generated SDKsHeld. OpenAPI 3.2 shipped; tool support trails the specification
Real-time and event-driven APIsHeld. Server-sent events gained the most ground

AI and APIs

The original article predicted APIs whose logic is produced by AI, and illustrated it with an endpoint that asked a model at request time to generate validation rules and rewrite its SQL. That example should not be copied. Validation rules that vary between requests are not validation, and SQL rewritten by a model on each call is slow, hard to test, and an injection risk. This did not become normal practice, for those reasons.

What did happen is at development time. Coding assistants are now routinely used to write API code: handlers, tests, client libraries, and OpenAPI descriptions. The output is ordinary code that is reviewed, tested and deployed like any other, so the API itself behaves deterministically.

The change the article missed is that AI agents became API consumers. In November 2024 Anthropic published the Model Context Protocol (MCP), a standard way to expose tools and data to language models. Other AI vendors and developer tools adopted it, and in December 2025 its governance moved to the Agentic AI Foundation under the Linux Foundation. The foundation's July 2026 revision made the protocol stateless, so MCP servers can run behind an ordinary load balancer.

For API designers the practical effect is a second kind of reader. An agent chooses which operation to call from its name, description and parameter schema alone, so vague descriptions and inconsistent error messages now cause failed calls, not just confused humans. APIStack exposes its APIs to agents this way, through the endpoint described in the MCP section of the docs.

The natural-language query idea in the original, turning a sentence into SQL, exists as a product feature in many data tools. It works when the generated query runs with read-only credentials against a limited schema and the result is shown with the query that produced it. It is not a replacement for a designed API.

GraphQL

The original called "Federation 2.0" the next generation of GraphQL. It was already current: Apollo Federation 2 had been generally available since 2022. Federation, where several services each own part of one graph and a router composes them, is now an established way to run GraphQL in a large organisation. Work on a vendor-neutral standard for it continues in the GraphQL Foundation's composite schemas specification.

The schema in the original article also misused two directives, attaching @requires and @provides where they have no effect. A correct minimal example is shorter. This is an orders subgraph that defines Order and contributes an orders field to the User entity owned by another subgraph:

GraphQL
extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.3", import: ["@key"])

type Order @key(fields: "id") {
  id: ID!
  total: Float!
  buyer: User!
}

type User @key(fields: "id") {
  id: ID!
  orders: [Order!]!
}

The specification itself moved after a long pause. The September 2025 edition was the first since October 2021, and added OneOf input objects, schema coordinates and descriptions on operations, among other changes.

The streaming features the original presented as arriving did not make that edition. @defer and @stream, which let a server send part of a response first and the slow fields later, are still a working group proposal. Several servers and clients implement them, but the wire format has changed between drafts, so treat them as implementation-specific. Live queries, also listed in 2024, were never standardised.

The original did not mention gRPC, and its position has not changed: Protocol Buffers over HTTP/2, used mainly between backend services, and reachable from browsers only through gRPC-Web and a proxy. The broad split of 2024 still holds. REST with OpenAPI is the default for public APIs, GraphQL serves client-facing aggregation, and gRPC serves internal calls.

Serverless and edge runtimes

The 2024 article expected APIs to move to edge runtimes, and supported the claim with latency and cold-start figures that had no source. Those figures have been removed.

The trend partly reversed. Vercel, whose Edge Runtime the original used as its example, now states in its Edge Runtime documentation that it recommends migrating from edge to Node.js for performance and reliability, and that from Next.js 16.3 the runtime = 'edge' setting is no longer supported.

The reason is architectural. An edge function runs close to the user, but most API handlers spend their time talking to a database that lives in one region. Moving the code away from the data adds a long round trip per query, which can cost more than the short hop saved for the user. Restricted runtimes also could not run many existing libraries. Edge execution remains a good fit for work that needs no central data: redirects, header rewriting, authentication checks on a signed token, and serving cached responses.

Serverless functions in a region next to the database did hold up as a default way to deploy APIs. The lasting part of the prediction was caching at the edge, not computing there.

The original code sample had a bug worth correcting, because it is a common one. It fetched one user's data with a server-side token and returned it with Cache-Control: public, which allows a shared cache to serve that user's data to someone else. Per-user responses must be marked private. This version uses the standard Request and Response objects and runs on any current JavaScript server runtime:

JavaScript
export async function GET(request) {
    const userId = new URL(request.url).searchParams.get('userId')
    if (!userId) return Response.json({ error: 'userId is required' }, { status: 400 })

    const upstream = await fetch(`${process.env.API_BASE_URL}/users/${encodeURIComponent(userId)}`, {
        headers: { Authorization: `Bearer ${process.env.API_TOKEN}` }
    })
    if (!upstream.ok) return Response.json({ error: 'Upstream request failed' }, { status: 502 })

    return Response.json(await upstream.json(), {
        headers: { 'Cache-Control': 'private, max-age=60' }
    })
}

One transport change arrived without any API redesign. HTTP/3, standardised as RFC 9114 in 2022, is negotiated by CDNs and browsers automatically. An API served through a CDN that supports it gets the benefit with no change to its endpoints.

Security

Zero trust was listed as an emerging shift. The principle, that no request is trusted because of where it comes from and every one is authenticated and authorized, was already written down in NIST SP 800-207 in 2020. It has continued to spread, mostly as service-to-service authentication inside networks that used to trust internal traffic.

The risks that matter most for APIs did not change. The OWASP API Security Top 10 still puts broken object level authorization first: an endpoint that checks that the caller is signed in but not that the requested record belongs to them. No architecture label fixes that. It takes an ownership check in every handler and tests that try to read another account's data.

The original grouped passkeys and magic links under API authentication. Those authenticate people signing in to an application. They do not authenticate an API client. For clients, the progress since 2024 is in OAuth. The IETF published its security best current practice as RFC 9700 in January 2025, which makes PKCE the norm for the authorization code flow, forbids the password grant and advises against the implicit grant. OAuth 2.1, which consolidates those rules into one document, is still an Internet-Draft as of this revision. Sender-constrained tokens, through DPoP or mutual TLS, address the weakness of bearer tokens, which is that a stolen token works for whoever holds it.

Short-lived tokens with rotation, the other item on the 2024 list, are standard practice and were sound advice then.

Developer experience

This prediction held with the least qualification. Reference documentation generated from an OpenAPI description, with a console to try requests and code samples in several languages, is now the expected baseline, and generating typed client libraries from the same description is routine.

The specification advanced. OpenAPI 3.2.0 was released in September 2025. It stays compatible with 3.1 and adds, among other things, a way to describe HTTP methods beyond the standard set, including QUERY, and better support for streamed responses such as server-sent events.

Tooling moves more slowly than the specification. Not every generator, gateway and importer reads 3.1 or 3.2 yet, so before upgrading a description, check that every tool in your pipeline accepts the new version. Publishing 3.0 remains a reasonable choice for compatibility, and it is the version of APIStack's own OpenAPI description.

The new requirement since 2024 is the one from the first section: documentation is now read by models as well as people. Complete descriptions, examples for every operation, and documentation available as plain text or Markdown help both audiences.

Real-time and event-driven APIs

WebSockets remain the standard choice for two-way communication, and nothing replaced them. The technology that gained the most is the simpler one. Server-sent events, a one-way stream over an ordinary HTTP response, gained attention because the major language-model APIs stream their responses that way. For server-to-client updates, try it before reaching for a WebSocket: it passes through proxies and load balancers as normal HTTP, and browsers reconnect automatically.

For describing event-driven interfaces, AsyncAPI 3.0, released in December 2023, separated channels from operations so that one document can describe both sides of a message exchange. Version 3.1 followed in 2026 as a minor release without breaking changes.

The original WebSocket example accepted connections first and waited for the client to send an authenticate message, leaving the other handlers reachable by unauthenticated sockets. Authenticate during the handshake instead, and check permission on each subscription. With Socket.IO:

JavaScript
io.use(async (socket, next) => {
    try {
        socket.data.user = await verifyToken(socket.handshake.auth.token)
        next()
    } catch {
        next(new Error('unauthorized'))
    }
})

io.on('connection', (socket) => {
    socket.join(`user:${socket.data.user.id}`)

    socket.on('subscribe', async (channel) => {
        if (await canRead(socket.data.user, channel)) socket.join(channel)
    })
})

The original also listed event sourcing and CQRS as trends. They are long-established architectural patterns with real costs in complexity, and whether to use them depends on the system, not the year.

Summary

  • The lasting AI change is not AI-generated runtime logic but AI agents as API clients, with MCP as the common protocol; clear operation descriptions and error messages now matter more.
  • GraphQL federation is mainstream and the specification is moving again, but @defer and @stream remain outside it.
  • Edge runtimes for API logic receded; keep compute next to the data and use the edge for caching and simple request handling.
  • The main API security risk is still missing per-object authorization; follow RFC 9700 for OAuth.
  • OpenAPI 3.2 and AsyncAPI 3 are current, but verify tool support before upgrading a description.

Build with APIStack

One API key for validation, dates and holidays, web checks and reference data, over REST or as MCP tools for your AI agents. The free plan includes 1,000 calls a month.

Keep reading