Skip to content
Customer Identity · available nowBuild your first Test integration.Create a Test project
NamoID
All posts
NamoID Blog

Using NamoID? Here Is the Product Security Your Team Still Owns

Assign product security responsibilities when using managed authentication. Map sessions, customer permissions, secrets, support access, and release evidence.

Retrospective series date: 2026-11-13. This label describes the series order, not a historical publication.

A managed authentication service changes who operates login. It does not remove your application's security responsibilities. Assign an owner and a test to each boundary before real customers depend on the product.

For a small Indian startup, this prevents a costly gap. The provider expects application access checks. The application team assumes login covers them. Use this responsibility map to make the handoff explicit.

Separate identity from a business decision

Authentication establishes control of an account or credential. Authorization decides whether the actor may perform a particular action. Your product needs both.

Consider a hypothetical invoice application. A user signs in correctly, then changes the invoice identifier in a request. The server must still check the user's active organization and permission for that invoice.

OWASP recommends denying access by default and checking permissions on each request. Use those principles when reviewing the server boundary. OWASP authorization guidance.

Identity service -> trusted identity context
                            |
Application -> active membership -> action permission -> customer record

The diagram describes separate decisions. It does not imply that a signed token contains the current result of every application policy.

Give each control an owner and evidence

Use the security responsibility worksheet. Replace each owner label with a responsible person or contracted team.

BoundaryTypical ownerEvidence to request
Provider credential checksIdentity serviceSupported-method configuration and failure test
Redirect and callback configurationApplication teamApproved callback and rejected mismatch
Application sessionApplication teamExpiry, renewal and logout behavior
Tenant and record permissionsApplication teamPositive and denied resource-access cases
Cloud credentialsInfrastructure ownerLeast-privilege access and rotation record
Support accessProduct operationsIndividual permissions and accountable actions
Incident escalationApplication and provider teamsContact route, decision owner and rehearsal
Personal-data handlingResponsible organizationProcessing map, retention and request workflow

The exact split depends on the service contract and deployment. Confirm it instead of assuming that “managed” includes every row.

Test a business permission with synthetic records

The following policy illustrates one narrow decision: an actor may read an invoice only with the required permission in the same organization.

export function canReadInvoice(actor, invoice) {
  if (!actor || !invoice) return false;
  if (typeof actor.organizationId !== "string" || !actor.organizationId) return false;
  if (typeof invoice.organizationId !== "string" || !invoice.organizationId) return false;
  return (
    actor.organizationId === invoice.organizationId &&
    Array.isArray(actor.permissions) &&
    actor.permissions.includes("invoice:read")
  );
}

Obtain the actor from a trusted server context. Load permissions from the application's reviewed policy. Browser input must not select an administrator identity or grant itself a permission.

Run the synthetic policy example with Node.js. It exercises the allowed case and rejects missing actors, missing permissions and incorrect organizations.

The example does not validate tokens, query a database or resolve live memberships. It demonstrates a policy boundary, not a complete authorization service. Use the multi-tenant authentication guide for the wider model.

Treat sessions as separate records of access

The provider can have a session while the application maintains its own cookie. An API access token can also remain valid after a browser session ends.

For each logout or disable action, record which component rejects the next request. Test an already issued token and an existing application session separately. Do not infer complete revocation from a successful logout screen.

Use the session and logout matrix. For staff changes, use the joiner, mover and leaver procedure.

Keep support and infrastructure inside the review

An administrator export, broad cloud credential or support override can expose customer data without a login defect. Include those paths in the responsibility worksheet.

Use individual operator accounts. Limit access to the tasks the operator needs. Keep secrets and raw authentication material out of analytics, screenshots and support messages.

When troubleshooting requires an example, use a synthetic account or a redacted failure stage. A working support channel should not depend on sharing a customer's live token.

Use evidence to decide whether to release

A green status needs an observed result. “The SDK handles it” is not evidence for an application-specific permission.

  1. Assign the owner for each worksheet row.
  2. Write the expected result before testing.
  3. Run the allowed and denied access cases.
  4. Test a removed membership with existing access.
  5. Record the observed result and remaining limitation.
  6. Assign a decision owner for each unresolved release risk.

Keep legal and contractual applicability decisions with the responsible organization. A security worksheet supports review; it does not establish compliance with an Indian regulatory framework.

Review the boundary with NamoID engineers

NamoID operates its hosted authentication service. Your application still owns its session, business authorization and launch review. The current Customer Identity scope states that boundary.

Our engineers can help review your callback, session model and token validation. Bring a responsibility worksheet and one synthetic denied-access case. We can help identify gaps between the service and your application.

Share your stack, use case and launch stage in Slack for an early response. Contact the NamoID team