Back to all posts
Security7 min read·October 26, 2026

Authentication vs Authorization: Who Can Do What?

TB
ThynkBlox Team
Engineering

What is the difference between authentication and authorization?

Authentication checks identity: who is making this request? Authorization determines what that identity may access or change. For example, signing in to an order-management application authenticates a salesperson; allowing that salesperson to edit only their assigned orders is an authorization decision.

For a product owner, the distinction becomes a practical question: after someone signs in, what exactly should the software let them do?

What do authentication vs authorization examples look like?

Consider a business application used by sales, finance, and support staff. The examples below describe an illustrative permission policy, rather than rules every business should adopt.

SituationAuthentication questionAuthorization question
A salesperson opens an orderWho is signed in?Is this order assigned to them?
A finance employee issues a refundWhich employee is requesting it?Does their role permit refunds on this order?
A customer downloads an invoiceWhich customer account is signed in?Does the invoice belong to that account?
A manager exports a reportWhich manager requested the export?Which records and fields may they export?
A support agent helps a customerWhich support agent is acting?May they view contact details or change account settings?

Write both questions into requirements. “Users must log in” describes an entry requirement. It does not define the permissions needed after entry.

For example, specify “Customers may download invoices belonging to their own account” instead of “Invoices require login.” The first statement gives the build team a decision they can implement and test.

How should you design roles?

Start with business actions, then group those actions into roles. Avoid beginning with vague labels such as “standard user” and expecting everyone to interpret them consistently.

For an illustrative order application, you might define:

  • Sales: create orders and edit assigned draft orders.
  • Finance: view billing details and issue approved refunds.
  • Support: view delivery information and add service notes.
  • Business administrator: invite employees and assign permitted roles.

Keep actions separate where the business makes separate decisions. Viewing an order, changing its delivery address, cancelling it, and exporting its details deserve explicit rules.

Also define what an administrator controls. In this example, managing employee access does not automatically include permission to issue refunds. If the business needs both capabilities in one role, grant both deliberately.

Use the smallest set of permissions that supports each job. Before adding an exception for a particular employee, ask whether it represents a real responsibility that needs a named role or a clearly scoped additional permission.

Why does record ownership matter?

A role describes a responsibility. Ownership or assignment describes the relationship between an identity and a particular record.

In our example, two salespeople share the same role. Each may edit assigned draft orders, but neither should edit the other's orders unless a separate rule permits it.

Define “own” precisely. It could mean:

  • Created by this person.
  • Currently assigned to this person.
  • Belonging to this person's customer account.
  • Belonging to the organisation where this person is acting.

These meanings are different. An employee might create an order for another salesperson, and an order might later be reassigned.

For software serving several businesses, make the organisation boundary explicit too. A manager's permission to view all orders should mean all orders within the permitted organisation. Decide separately whether any role needs access across organisations.

Apply that scope to search results, dashboard totals, attachments, and exports as well as individual record pages. In the illustrative policy, a salesperson's report includes the same assigned orders they may open individually.

Where should permission checks happen?

Require the server to check permission before returning protected information or accepting a change.

A hidden button is useful guidance for the user, but browser controls alone cannot enforce access: someone can send a request without using the visible interface.

For each protected request, define the decision using:

  • The authenticated identity.
  • The organisation or account where they are acting.
  • The requested action.
  • The target record and its ownership or assignment.
  • Any relevant state, such as whether an order is still a draft.

Treat submitted role names and ownership claims as untrusted input. Require the server to establish the caller's permissions and the record's actual scope before proceeding.

Choose denial as the default when no rule grants access. Make exceptions explicit, including public pages and records intentionally shared with guests.

For broader context, see data security in modern applications.

What does a complete permission decision look like?

Take an illustrative request to change a delivery address.

The proposed policy says a salesperson may change an assigned order's address while that order is a draft. After confirmation, only a designated operations role may make that change.

The decision should answer these questions in order:

  1. Is there an authenticated identity?
  2. Does the order belong to the organisation where that identity is acting?
  3. Does the identity have permission to change delivery addresses?
  4. Does the assignment rule permit access to this order?
  5. Does the order's current state permit this change?
  6. Are the submitted fields limited to those this action allows?

That last question matters to the policy. An address-editing action should not also accept a submitted refund status or reassignment.

Define the result of denial too: leave the record unchanged and show a useful message without revealing protected details. For example, “You do not have access to this order” may be appropriate where the policy permits acknowledging its existence.

How should you test permissions?

Test both allowed and denied actions. An administrator completing a task successfully proves only that one permitted path works.

Use a permission table as the basis for acceptance tests. This illustrative table follows the order policy above.

Test caseExpected result
Assigned salesperson edits a draft order's addressAllow
Another salesperson submits the same changeDeny; leave the order unchanged
Assigned salesperson edits a confirmed orderDeny
Permitted operations employee edits a confirmed orderAllow
Employee from another organisation requests the orderDeny; return no order details
Address update also submits a refund-status changeReject the disallowed change
Salesperson exports ordersInclude only permitted records and fields

Exercise denied cases through direct requests as well as the interface. Check the response, stored record, and any side effect, such as a notification or generated export.

Include changes to access in the tests. Remove a role, reassign an order, or remove organisation membership, then verify that subsequent requests follow the revised policy. Decide explicitly how quickly access changes must take effect.

These cases belong alongside the practices covered in software testing and quality assurance and the web application security checklist for founders.

What common mistakes should product owners watch for?

Treating login as blanket permission. Replace “signed-in users can access orders” with specific actions and record scopes.

Making every employee an administrator. Define the permissions needed for daily work before using broad access to resolve a blocked task.

Checking the page but overlooking its data. Include record downloads, searches, attachments, reports, and background jobs in the permission requirements.

Leaving ownership undefined. Decide whether access follows the creator, current assignee, customer account, organisation, or another stated relationship.

Ignoring record state. Specify whether actions remain available after approval, confirmation, cancellation, or closure.

Testing only successful actions. Require evidence that forbidden actions fail and leave protected information and records untouched.

What should you agree before development starts?

Bring a compact permission brief to the build discussion:

  • Named roles and the actions each may perform.
  • Record ownership and organisation boundaries.
  • State-dependent restrictions.
  • Exportable records and fields.
  • Who may grant, revoke, or delegate access.
  • Expected behaviour when access changes.
  • Allowed and denied examples for acceptance tests.

Resolve unclear business rules before turning them into software. A precise permission table gives the product owner, developer, and tester a shared definition of correct behaviour.

Frequently asked questions

Does every application need roles?

No. For a simple personal tool, an ownership rule may be sufficient: each person manages their own records. Add roles when distinct responsibilities require different permissions.

Can someone be authenticated but unauthorized?

Yes. In the worked example, a salesperson is signed in but cannot edit another salesperson's order. Their identity is established; the requested action is denied.

Is a hidden edit button enough?

No. Use it to guide the interface, and require the server to enforce the same permission rule when a change is requested.

What should founders ask a software partner to demonstrate?

Ask for one permitted action and several denied attempts against the same feature. Include another person's record, another organisation's record, and a direct request. Review the resulting data as well as the message on screen.

For connecting to outside services, see API keys vs OAuth.

When business customers want to manage sign-in centrally, read when business software needs single sign-on.

To prepare for the case where access controls fail, see what a security incident response plan should include.

Ready to build?

Let's turn these ideas into your next product.

Start your project