The Scope Creep Automated reviews of new AI-related working group submissions

Review · August 26, 2026

SCIM Group Member Resource Type Extension

draft-zollner-scim-group-members -01View on Datatracker →

draft-zollner-scim-group-members-01 — Danny Zollner (Okta), submitted 15 April 2026. Individual submission, intended status Standards Track.

The Problem Statement

A group with a million members does not fit in an HTTP response.

RFC 7643 models membership as an array inside the Group resource. SCIM paginates lists of resources, not arrays inside a resource. So GET /Groups/{id} either returns every member or none. The draft puts the number at roughly 200MB for a million-member group, and says the payload can exceed 100MB well before that.

The abstract includes the detail that matters most: this has "led to many major SCIM implementations choosing to not support returning the value of the members attribute." That's not a hypothetical scaling concern. It's a feature that vendors have already turned off, which means clients today have no interoperable way to read a large group's membership at all.

The fix is to stop treating membership as an attribute. Make it a resource. GET /GroupMembers?filter=group.value eq "..."&count=1000 and every SCIM query feature works, because you're now paginating a list of resources like SCIM always could.

How the Spec Fits In

This is the third live approach to one chartered problem, and it's the one that requires the least new protocol machinery.

The SCIM charter puts "Multi-Value Query Filtering and Paging" in scope for the RFC 7643/7644 revision, naming draft-hunt-scim-mv-paging as input. This draft doesn't do multi-value paging. It removes the need for it in the group case by moving the data out of the multi-valued attribute entirely. That makes it an alternative to a chartered work item rather than an instance of one, which is a distinction the working group will have to resolve.

The competing designs:

  • draft-hunt-scim-mv-filtering adds bracket qualifiers to the attributes parameter, so members[count=5&startIndex=1] slices the array in place. Expired, but it's the charter's designated starting point.
  • draft-kushwaha-scim-attr-cursor-pagination adds attributeCount and attributeCursor query parameters for the same purpose. Submitted a week before this draft.
  • This draft flattens the relationship into /GroupMembers.

The flattened model wins on one point that's hard to argue with: it invents no new query syntax. Index pagination from RFC 7644, cursor pagination from RFC 9865, filter, sortBy, and /Bulk all apply unchanged. The other two designs each require new parameters, new response attributes, and new discovery, and neither has defined error semantics or ordering rules yet.

The pattern also has real deployment history, just not inside SCIM. Microsoft Graph exposes /groups/{id}/members as a paginated collection. Okta has /api/v1/groups/{id}/users. Google's Directory API has a Members resource. Every large identity provider that solved this problem solved it this way. The charter says the working group "will also consider publishing extensions to SCIM that have found broad adoption," and the honest reading is that the pattern is broadly adopted while this particular SCIM binding of it has zero implementations.

Dependencies are lean: RFC 7643, RFC 7644, RFC 9865, plus BCP 14. No new roles, no new endpoints outside the normal resource type convention, no new authorization model. For a Standards Track extension this is about as small a footprint as you can have.

One gap worth naming. The working group's own use-cases-reloaded draft never mentions large groups. Not once. If this is the biggest scale failure in deployed SCIM, and vendors have already disabled a core attribute because of it, that use case belongs in the document the working group is writing to capture use cases.

High-Level Summary

Today a client that needs a large group's membership has no good option. Ask for the Group and get a timeout, a truncated list with no indication it was truncated, or a response with members silently omitted. Or reverse the query to GET /Users?filter=groups.value eq "...", which paginates properly but has patchy support across implementations.

This draft adds a /GroupMembers endpoint. Each resource is one link: a group reference and a member reference, plus server-generated id and meta. Adding a member is POST /GroupMembers. Removing one is DELETE /GroupMembers/{id}. There is no PATCH and no PUT, on the reasoning that changing either end of a link produces a different link. That's correct and it keeps the resource model simple.

Two filters are mandatory, and they're the two that matter. Filter on group.value to get a group's members. Filter on member.value to get a user's groups. The second one quietly gives SCIM a scalable replacement for the groups attribute on User, which has the identical problem in reverse for a user in ten thousand groups. The draft never mentions this, and it should, because it's one of the stronger arguments for the design.

The second mechanism is a Group extension called membersMetadata. It tells a client how a given group's membership is managed, with three values: inline means members are all in the members array and you shouldn't bother with /GroupMembers; external means members is omitted and /GroupMembers is the only source; hybrid means both exist and /GroupMembers is canonical. It also carries a pre-built query URL, an optional total count, and an optional list of allowed member types.

Providers that keep supporting members for backward compatibility must keep both views consistent in both directions. Delete a GroupMember and the entry leaves the array. PATCH the array and the GroupMember resource is deleted.

Significant Interoperability Concerns

A read-modify-write PUT can delete every member of a group. This is the one that needs fixing before anything else. When policy is external, the Group representation omits members. A client GETs the group, changes displayName, and PUTs the result. The members attribute defaults to readWrite mutability in RFC 7643, and RFC 7644 §3.5.1 says the service provider MAY assume omitted readWrite values are to be cleared. A conforming server can wipe a 150,000-member group because the client did exactly what the spec told it to do. Under hybrid it's worse, because the draft says the provider MAY return members without saying whether that array is complete, so a client can write back a truncated list. The draft needs to state that members is not writable via PUT when a GroupMembers policy is in effect, or that providers MUST ignore it.

Clients can't delete a membership without a lookup first. DELETE requires the GroupMember id. The id is server-generated and clients MUST treat it as opaque. To remove Babs from the Sales Team, a client has to search for the membership, get the id, then delete it. Two round trips per removal, and the mandatory filter language only names group.value and member.value individually. It never says a compound group.value eq X and member.value eq Y filter has to work, which is the only filter that actually finds the resource you want. The bulk example in §6.4 sidesteps this by deleting a hard-coded gm12345. Real sync clients don't have that. Options: mandate the compound filter, define a deterministic composite id, or allow DELETE by filter.

POST is not idempotent and 409 doesn't help. Duplicate membership MUST return 409 Conflict. The draft doesn't say the 409 carries the existing resource's id or Location. So a client whose POST times out cannot tell whether its own request succeeded or the membership already existed, and it can't recover the id either way. PATCH with an add operation on members degrades gracefully here. This design doesn't, unless the 409 is made informative.

Nothing defines ordering. The abstract sells sorting as a benefit. Sorting appears nowhere else in the document. Cursor pagination over an unordered mutable set is not safe: a member added between page 3 and page 4 causes skips or duplicates. RFC 9865 assumes a stable order exists; this draft needs to say what it is, or at minimum require that providers maintain one.

GET /GroupMembers with no filter returns every membership on the server. For a large tenant that's tens of millions of resources and a broad data exposure surface. §8.3 handles authorization in general terms. The draft should say providers MAY require a filter and return 400 otherwise.

Read-only support is signaled by overloading mutability. §4.1 says a provider that doesn't support create or delete MUST set every attribute in the /Schemas definition to readOnly. So a client discovers whether POST works by diffing immutable against readOnly on group.value. It works, but it's indirect enough that implementers will get it wrong. A boolean in the ResourceType or /ServiceProviderConfig entry would be unambiguous.

"Transactional integrity" is stronger than most providers can deliver. §7.1.2 requires it between members and the GroupMember resources. Many providers back these with different stores and can only offer eventual consistency. As written this is either unimplementable or unenforceable, and it isn't observable at the protocol level in any testable way. Better to specify the observable requirement: after a successful DELETE, a subsequent GET of the Group MUST NOT include that member.

Bulk with bulkId references is unaddressed. The highest-value bulk pattern is creating a User and adding it to a group in one request, using "member": {"value": "bulkId:qwerty"}. RFC 7644 §3.7.2 resolves bulkId references in value sub-attributes, so it should work, but the draft's example only uses pre-existing ids and never confirms it. That's the case implementers will ask about first.

inline versus hybrid is underspecified. Under inline, clients SHOULD NOT use /GroupMembers. Does that mean the endpoint won't return results for that group, or just that it's unnecessary? A client that wants one code path for all groups needs to know. And because policy is per-group, clients must fetch the Group before they know how to read its members, adding a round trip they'd otherwise skip by always going to /GroupMembers.

Mechanisms That Could Be Removed

ref is REQUIRED and fully derivable. It's the GroupMembers endpoint plus ?filter=group.value eq "[Group_ID]". The client already has the group id and can find the endpoint in /ResourceTypes. Requiring servers to construct this string buys nothing and creates a place for them to disagree on URL encoding, which the draft's own examples demonstrate: both are wrapped with line-continuation backslashes and percent-encoded quotes that make the intended value ambiguous. Make it OPTIONAL or drop it.

allowedMemberTypes doesn't affect interoperability. If a client POSTs a disallowed member type, the server returns an error. The list saves a round trip and nothing else. Reasonable to keep as OPTIONAL, which it is, but it's the first thing to cut if the document needs to shrink.

Three policy values where two would do. The information a client needs is: is members complete, and should I use /GroupMembers. hybrid and inline differ only in advice, not in observable behavior. Collapsing this would remove a decision that two implementations will make differently for the same group size.

memberCount is correctly OPTIONAL. Counting a million-member group is expensive on many backends, and the draft gets this right where other pagination drafts have made it look mandatory.

Writing Quality

This reads like a document written by someone who has shipped an RFC. Discussion Venues section, table of contents, BCP 14 boilerplate, proper reference formatting, a real IANA section with both registrations spelled out. It went through the toolchain. Sentences are short and grammatical. There's no padding and no marketing language. At 19 pages with roughly half of that being JSON, the prose is about as compact as the material allows.

A few things to clean up.

Security Considerations is §8.3 and IANA Considerations is §8.4, both nested under "Schema Representation." Those belong at the top level. Reviewers notice this immediately and it looks like a template error rather than a choice.

§7.1.1 points to "Section 2.3 of this document" for the schema definition. The schema is in §8.1 and there is no §2.3.

The Introduction says "the System for Cross-domain Identity Management (SCIM) 2.0 protocol RFC7643 [RFC7644]," which names one RFC and cites the other.

The filter example in §6.2.2 is missing its opening quote: filter=group.value eq e9e30dba-...b05".

There are no informative references. The document doesn't cite draft-hunt-scim-mv-filtering or draft-kushwaha-scim-attr-cursor-pagination, which are the two competing solutions to the problem it's solving. A reader can't tell from this document that alternatives exist. That's the same omission the Kushwaha draft has in the other direction, and both drafts are weaker for it.

The Security Considerations section is short but says two useful and non-obvious things: read access to a Group does not imply read access to its members, and PATCH authority on members has to translate to POST and DELETE authority on GroupMember resources. The second one is exactly the kind of privilege-mapping bug that shows up in real deployments when a new endpoint bypasses the authorization checks on an old one. Good to see it called out. It could go further on the unfiltered GET /GroupMembers case.

Background of the Author

Danny Zollner (Okta) has one published RFC: RFC 9865, cursor-based SCIM pagination, published October 2025 with Mike Peterson and Anjali Sehgal. That's directly adjacent to this work, and this draft is normatively built on it.

Four active drafts, all SCIM:

  • draft-zollner-scim-group-members
  • draft-zollner-scim-interop-profile
  • draft-wzdk-scim-agent-resource (co-author)
  • draft-schreiber-scim-ipsie-profile (co-author)

Expired drafts include draft-ietf-scim-roles-entitlements, which is a working group document, plus draft-sehgal-scim-delta-query, draft-zollner-scim-referential-value-location, and draft-zollner-scim-domain-extension.

Not a new author. Has shipped an RFC in this working group, has been an editor on an adopted working group draft, and every document with his name on it is SCIM. The pattern is a specialist working one protocol over several years, which is the profile you want on a Standards Track extension to a core resource model.

Suggested Feedback

The problem is real and the approach is the most protocol-conservative of the three on the table. The useful feedback is mostly about closing gaps rather than redirecting the work.

Start with the PUT hazard. In external mode the Group representation omits members, RFC 7644 lets a server clear omitted readWrite attributes, and the obvious client pattern is read-modify-write. Say plainly what a provider does with members in a PUT when a GroupMembers policy is in effect. Also state whether hybrid means members may be truncated.

Ask how a client deletes a membership it didn't just create. Mandate the compound filter on group.value and member.value, or define an id the client can compute, or allow DELETE by filter. Right now the only worked example deletes an id that appeared from nowhere.

Ask for the 409 response to carry the existing resource's id. Without it, POST retry after a timeout is unrecoverable, and sync clients retry constantly.

Ask what the default sort order is. The abstract promises sorting and cursor pagination needs a stable key. Neither is specified.

Push back on ref. It's required, derivable, and the two examples in the document don't agree on how to encode it. That's the definition of a mechanism that hurts interoperability instead of helping it.

Ask for the bulkId reference case to be shown explicitly. Create a User and add them to a group in one bulk request is the operation every provisioning client wants, and the draft's bulk example doesn't cover it.

On process, the direct question for the working group is whether this and the two multi-valued pagination drafts get evaluated together. They solve the same chartered problem with incompatible designs, and picking one is a decision the working group should make on purpose rather than by whichever draft gets adopted first. This draft should argue its case in the document: no new query syntax, no new discovery, and the pattern already runs in production at Microsoft, Okta, and Google. That argument is stronger than anything currently in the introduction.

Last thing: get large groups into draft-ietf-scim-use-cases-reloaded. Vendors have disabled a core RFC 7643 attribute over this, and the working group's use cases document doesn't mention it.