AEM and GraphQL: Permission Filtering for Headless Delivery
Headless delivery has changed how many teams think about Adobe Experience Manager. Instead of server-rendered pages from Sightly templates or one broad JSON endpoint, Australian organisations increasingly publish content fragments through GraphQL so that mobile apps, React single-page applications, and partner integrations can request exactly the fields they need. The appeal is obvious: one endpoint, a typed schema, and no over-fetching. The catch is that a single GraphQL URL collapses your entire content tree behind a query string, and the authorisation logic that once lived in the Sling resource hierarchy has to be rebuilt in application code.
Getting that rebuild right is where permission filtering earns its place. A resolver that hands back a content fragment without checking whether the requesting principal may read it turns a well-intentioned API into a data leak, and leaks are easier to cause in a headless setup because the response travels to devices and third parties you don't control. CIRCUIT, the two-day Adobe developer conference held in Chicago for Java developers, AEM architects, front-end engineers, and systems engineers, covered integrations, Sightly, microservices, IoT, open source, analytics, and architecture — and the recurring question beneath all of it was how you keep the content bus secure once the render layer disappears.
Where AEM's permissions actually come from
AEM's security model rests on Oak: principals, groups, and access control lists attached to nodes. Users authenticate against an identity provider, group membership resolves at request time, and the resource tree filters accordingly. Content fragments live under /content/dam, with their models under /conf. So a defensible answer to "who may read this?" already exists inside the platform — the real work is reproducing it faithfully when a resolver serialises a fragment into JSON and sends it to a phone in Brisbane.
Three states matter here: not found, found but forbidden, and readable. Headless clients routinely collapse the first two into a null. When a resolver returns nothing for restricted content without a typed error, the client cannot distinguish a deleted draft from a restricted fragment, and that ambiguity frustrates editors debugging why a campaign asset isn't rendering on the store app.
Granularity makes it harder. A single GraphQL query might span six fragments across three regions and a couple of content types. A merchandiser with rights to Sydney content but not to Melbourne campaigns expects a partial result, not a rejected query. That pushes you toward per-field authorisation rather than a request-level denial, and toward an error strategy that reveals nothing about content the caller isn't permitted to see. An error that says "no access to /content/dam/wollies/melbourne/q4" has already leaked the path.
Modelling permissions into the schema
Start with the content fragment model itself. Separate the fields that describe content — title, summary, price, region, SKU — from the fields that describe governance: owner, classification, embargo date, allowed channels. Keeping governance fields explicit in the model means a resolver can filter on documented data rather than on hard-coded path conventions. For a Woolworths or Coles campaign library, region and channel are natural filter dimensions; for a government service sitting in Canberra, classification and embargo dates do the work. The same model serves both audiences, which is one of the nicer properties of modelling content as data.
GraphQL also lets you express authorisation as part of the type system. A permittedActions type attached to each fragment can return booleans computed from the principal's group membership, and a restrictedReason field can stay empty unless the caller has the rights to see it. Persisted queries deserve attention too: an allow-list of named operations removes the "client picks any field at will" problem and gives you a stable contract to regression-test against, which matters when several squads consume the same schema.
If your organisation is consolidating older platforms at the same time, reading about AEM content migration strategies is a sensible adjacent step — the fragment models carrying your permission metadata usually have to survive that migration intact, and they are much cheaper to reshape before traffic moves than after.
Resolver level checks and group membership
The cleanest implementation wraps the resolver. Resolve the principal from the request (an IMS token, a service token, or an existing AEM session), expand that principal's group membership through the UserManager, then evaluate the access control list against the fragment's path before the fragment is materialised into a response object. Doing this inside the resolver rather than in a servlet filter keeps the check next to the data and makes it straightforward to unit test.
Group hierarchies complicate things in ways that catch people out. A principal may sit in authors, which nests into content-authorised, which nests into everyone, and Oak evaluates ACLs along that chain in ways a naive membership lookup won't reproduce. Cache group membership per session rather than per request to keep latency sane, but invalidate on login and on any membership change — otherwise a revoked contractor's access survives for the length of your cache TTL. In a market where contractors and agency staff get access to media libraries for a six-week campaign and then lose it, that gap is worth closing properly.
The CIRCUIT programme is a good place to see how practising AEM architects frame this kind of work; the speaker profile for about-icf-olson is one entry in a track that covered Java, architecture, and integration topics in Chicago.
Caching, tokens and edge delivery
This is the sharp end of the problem. If a GraphQL response is cached at the CDN without regard to who asked for it, permission filtering is theatre. You need either a private cache key that includes a fingerprint of the caller's permissions, or a shared public variant for anonymous traffic alongside a private one for authenticated requests. The fingerprint should be derived from hashes of group membership and the fragment paths actually touched, not from the raw token, so it stays stable and short.
Token validation at the edge carries its own traps. Introspection should be disabled in production and the schema published separately for partner developers, because an endpoint accepting arbitrary operation names and free-form query strings invites schema enumeration. Rate limiting, query depth limits, and a cost analyser then become part of your security posture rather than optional hygiene.
Latency shapes the design more in Australia than people outside the market assume. Sydney and Melbourne traffic usually reaches the same edge node, but regional traffic out of Perth or Darwin travels further, and NBN fixed-line performance varies noticeably between suburbs and technologies. Add an identity lookup to a personalised response and you have added a round trip that no amount of caching removes. Personalisation based on who someone is also means the cache key must reflect it.
Where analytics overlaps with all of this, the discussion around AEM and Apache Spark analytics is worth a look: any event data referencing fragment identifiers inherits the sensitivity of whatever permission filtering changed in the response, so segmentation belongs server-side where the rules already apply.
Testing, auditing and the wider ecosystem
Treat authorisation rules as code with a test suite behind them. Every resolver deserves cases for an anonymous caller, an authenticated content author, a restricted contractor, and a principal whose rights arrive through two levels of group inheritance. Assert on response shape as well as status codes, because a forbidden fragment returning null behaves differently from one returning a redacted object, and front-end teams feel that difference immediately.
Log denials with the same care as successes. A resolver that quietly drops content leaves no trail, and when someone reports that the app is missing the Brisbane press release, you want to know whether it was filtered, unpublished, or genuinely absent. Structured log entries carrying fragment path, principal identifier, and decision turn a two-minute query. The same discipline applies to AEM as a Cloud Service and to self-managed instances, though the mechanisms for obtaining credentials differ.
The wider conversation continues through the community around the DevPulseCon community, where AEM practitioners compare notes on microservices, open source tooling, and delivery architecture between conferences.
If your team is building a headless AEM stack and wants the permission model settled early rather than discovered during a penetration test, the CIRCUIT recordings and agenda archive are a practical place to start — the 2015 and 2016 sessions cover exactly the integration and architecture ground this problem sits on. Bring your resolver design, your group hierarchy, and your caching strategy; the sessions run on the assumption that attendees will argue about them. Register for the next event, submit a talk if you have shipped something worth discussing, or follow the session archives to catch up on the material you missed. A well-filtered GraphQL layer is not a finishing touch, it is the difference between a content API your security team trusts and one they ask you to switch off.