Authentication proves who someone is; authorization decides what they're allowed to do once you know. Nearly every "permissions bug" QA files is actually a design ambiguity — nobody defined what a role should be able to see or touch in that specific edge case. Fix the model, not just the code.

Quick answer: Authentication (authn) verifies identity — passwords, SSO, biometrics. Authorization (authz) governs permissions — what an authenticated user can read, edit, or delete. Most "access bugs" are really unspecified authorization rules, not broken login systems.

Why This Two-Word Mix-Up Costs Real Sprints

Authentication and authorization get compressed into one blob called "login" in early PRDs, and that compression is where the trouble starts. A PM writes "users can log in and see their dashboard" without specifying which dashboard, whose data, or what happens when a role changes mid-session.

Engineers then make judgment calls under deadline pressure, and those calls become the de facto spec. Six months later, a support ticket reveals a Viewer could edit a record because nobody drew the boundary. That's not a bug in the traditional sense — it's an undocumented decision.

  • Authentication bugs feel binary: you're either logged in or you're not, and they're usually caught fast because login itself is highly tested.
  • Authorization bugs are combinatorial: role × resource × action × state, and most teams only test the happy path.

The asymmetry matters. A broken login is loud and gets fixed same-day. A broken permission boundary is quiet — it just leaks data or blocks a legitimate user — and it can live in production for months. The OWASP Top 10 has ranked "Broken Access Control" as the number one web application risk in its most recent list, ahead of injection and cryptographic failures, precisely because authorization logic is scattered, under-specified, and rarely covered by a single source of truth.

Authentication: Proving Identity, Nothing More

Authentication answers exactly one question — is this person who they claim to be — and it should never be asked to answer anything else, like what they're permitted to do next. Confusing the two is the single most common root cause of access-control incidents in production systems.

Think of authentication as the building's front desk checking your ID. It confirms you are Jane Doe. It does not decide which floors your badge opens — that's a separate system, physically and logically.

The Common Authentication Mechanisms

MechanismHow it proves identityTypical PM consideration
Password + sessionShared secret matched server-sideReset flow, lockout thresholds, breach exposure
Multi-factor (MFA)Something you know + something you haveAdoption friction vs. security requirement
SSO (SAML/OIDC)Trust delegated to an identity providerEnterprise sales blocker if missing; who owns the IdP relationship
OAuth (as login)Token issued by a third party (Google, Microsoft)Consent screen, scope creep, token expiry UX
Biometric/passkeyDevice-bound cryptographic proofRecovery path when device is lost

What PMs Should Actually Spec

  1. Failure states: What does the user see after 3 failed attempts? 5? Is there a cooldown or a lockout?
  2. Session lifetime: Does a session expire after 15 minutes of inactivity or 30 days? Different products justify wildly different answers.
  3. Recovery paths: Password reset, lost 2FA device, and lost passkey device all need a defined, supportable flow — not "engineering will figure it out."
  4. Cross-device behavior: Does logging in on a new device invalidate other sessions? Should it?

None of this is authorization yet. It's all still "are you really you." If your spec conflates a session-timeout decision with a "can this user edit billing" decision, that ambiguity will resurface as a bug report.

Authorization: The Permission Model Nobody Fully Wrote Down

Authorization is the rule set that maps an authenticated identity to a set of allowed actions on specific resources, and it's where the real product design work lives. Unlike authentication, there's no industry-standard UI pattern to copy — every product's authorization model is bespoke.

That bespoke-ness is exactly why it goes sideways. Teams borrow a generic "Admin / Member / Viewer" pattern from a competitor without asking whether their own resource hierarchy actually maps to three flat tiers.

A Concrete Role-Modeling Example

Take a project management tool with three roles: Admin, Member, Viewer. On the surface it looks simple. Under the surface, every resource-action pair needs an explicit answer.

ActionAdminMemberViewer
View projectYesYesYes
Edit tasksYesYesNo
Delete projectYesNoNo
Invite new membersYesDependsNo
See billing detailsYesNoNo
Export dataYesDependsDepends

Notice the "Depends" cells. That's not sloppy table-making — that's where the real product decisions live, and where most teams stop specifying and let engineering guess. Can a Member invite another Member, or only invite Viewers? Can a Viewer export data they can see, or is export itself an elevated action distinct from viewing?

Every "Depends" in a permission matrix is a decision a PM owes the team before a single line of authorization code is written.

Role-Based vs. Attribute-Based Models

Simple products can usually get by with role-based access control (RBAC): a fixed set of roles, each with a fixed set of permissions. It's easy to reason about and easy to explain to customers.

As products mature, teams often outgrow flat roles and reach for attribute-based access control (ABAC), where permissions depend on attributes — the resource owner, the project's status, the time of day, the requester's department. NIST's guidance on access control models documents this RBAC-to-ABAC progression as a common maturity path for enterprise software, not a sign that the original RBAC design was wrong.

  • Choose RBAC first if your roles map cleanly to job functions and don't need per-object exceptions.
  • Reach for ABAC when you hear "well, except when..." repeatedly in permission conversations — that phrase is the tell.
  • Avoid inventing a fourth role (like "Super Member") to patch one edge case; it usually signals an attribute problem disguised as a role problem.

Tokens and Sessions: What's Actually Being Passed Around

A token or session ID is simply a piece of evidence the server trusts to mean "this request already proved who it is," so the system doesn't ask for a password on every click. Understanding the shape of that evidence helps a PM spot risk in a technical design review without needing to read the code.

Sessions vs. Tokens at a Glance

ConceptWhere it livesWho validates itPM-relevant tradeoff
Session ID (cookie)Server-side store + browser cookieYour own server, every requestEasy to revoke instantly; doesn't scale across services well
JWT (JSON Web Token)Encoded in the client, sent with requestsAny service with the signing keyHard to revoke before expiry; scales well across microservices
Refresh tokenStored securely client-sideAuth server, to mint new access tokensLong-lived, high-value target if leaked
API keyStored in a backend or CI systemThe API itselfOften over-scoped; rarely rotated

The practical PM takeaway: a JWT that's valid for 24 hours can't easily be "logged out" the instant you revoke a user's access, because there's no central lookup happening on every request. If your product has a compliance requirement around immediate access revocation — an offboarded employee, a suspended account — ask engineering directly whether tokens are checked against a live revocation list or trusted blindly until expiry. That single question separates a real security answer from an optimistic one.

OAuth Explained at a PM Altitude

OAuth is a delegation protocol: it lets your app act on a user's behalf at another service (or lets another identity provider vouch for a user) without your app ever seeing that user's actual password. It's an authorization framework by name, but in consumer products it's most often used to bootstrap authentication — "Sign in with Google" is OAuth doing an authentication job.

The Flow, Without the Jargon

  1. Your app redirects the user to Google (or Microsoft, GitHub, etc.).
  2. The user logs into Google directly — your app never sees that password.
  3. Google shows a consent screen: "Prodinja wants to access your email and profile."
  4. Google redirects back to your app with a token proving the user approved specific scopes.
  5. Your app uses that token to fetch the approved data — nothing more, nothing less, if scopes are respected.

Where PMs Get Burned

  • Scope creep: Requesting more permissions than the feature needs inflates the consent screen, which measurably increases signup abandonment and looks alarming to security-conscious enterprise buyers.
  • Token expiry UX: What happens when the OAuth token silently expires mid-session? A jarring re-auth interrupt is a UX decision, not just an engineering detail.
  • Third-party outage dependency: If Google's identity service has an incident, and it's your only login method, your product goes down with it. That's a real business-continuity conversation, not a hypothetical.
  • Enterprise SSO expectations: Mid-market and enterprise buyers frequently require SAML or OIDC-based SSO as a security-review checkbox; the IETF's OAuth 2.0 specification and the SAML standard maintained by OASIS are the two you'll hear referenced in vendor security questionnaires.

OAuth answers "can this app act as this user at this other service." It does not, by itself, answer "what can this user do inside your app." That second question is still yours to design.

Where This Connects to Prodinja

When you design protected endpoints in Prodinja's API Designing tool — moving from endpoints to a spec with curl examples — you're forced to name who may call each one. That single step, done for every endpoint, is what turns a vague "users can access their data" requirement into an explicit, testable authorization model instead of an assumption engineering has to invent under deadline pressure.

This is the same discipline behind good technical specs generally — see our complete guide to technical foundations for PMs for how this fits into the broader set of concepts (APIs, technical debt, how the web works) that make these conversations possible in the first place.

Key Takeaways

  • Authentication proves identity; authorization grants permissions — treat them as two separate specs, not one "login" ticket.
  • Most permission bugs are undocumented design decisions, not broken code — write down every "Depends" in your permission matrix before engineering builds it.
  • Start with RBAC for simple products; move to ABAC when you keep hearing "well, except when..."
  • Sessions and tokens trade off revocability against scalability — ask explicitly whether your product needs instant access revocation.
  • OAuth is a delegation protocol often reused for login; watch scope creep, expiry UX, and third-party outage risk.
  • Naming who can call each endpoint — as you do when designing an API for a product feature — is the fastest way to surface authorization gaps early.

Frequently Asked Questions

What's the simplest way to explain authentication vs authorization to a stakeholder?

Authentication is the ID check at the door; authorization is the list of rooms your badge opens once you're inside. One confirms identity, the other governs access — and a product can have flawless authentication with completely broken authorization, or vice versa.

Is OAuth the same thing as authentication?

No — OAuth is technically an authorization delegation protocol, but "Sign in with Google" style flows repurpose it to handle authentication too, using an extension called OpenID Connect (OIDC) built on top of OAuth 2.0. The distinction matters when engineering says "we use OAuth for login" — ask whether OIDC is layered in for identity verification specifically.

How many roles should a permission system have?

As few as your actual job functions require — most products do fine with three to five roles (like Admin, Member, Viewer) before reaching for attribute-based rules. Adding a new role for every edge case is usually a sign you need an attribute-based exception, not another tier.

Why do access-control bugs slip past QA so often?

Because they're combinatorial — role times resource times action times state — while most test plans only cover the happy path for each role individually. Testing "can a Viewer edit" is common; testing "can a Viewer who was just downgraded from Member still access a page they had open" is rare, and that's where bugs live.

Should a PM be involved in choosing RBAC vs ABAC?

Yes, because it's a product decision disguised as a technical one — it determines how much configurability you expose to customers and how support tickets about permissions get resolved later. Engineering can implement either model, but only the PM knows how customers actually think about their teams' structure.