START HERE

What you will learn

  • Understand what the web Top 10 can and cannot establish.
  • Connect risk categories to ordinary application behaviour.
  • Create a small, evidence-based review plan.

Before you start: A simple diagram of a web application helps. Test only systems and accounts you are authorised to assess.

Reference edition: OWASP Top 10:2025. Sources checked 2026-11-11.

Read categories as prompts for investigation

The 2025 edition covers areas including Broken Access Control, Security Misconfiguration and Software Supply Chain Failures. They describe families of problems rather than ten tests that can prove an application safe.

For example, a customer portal might correctly identify a logged-in person but still return someone else’s record. That is an access decision to investigate. A build pipeline might use reviewed source but pull in an unexpected dependency. That raises a different question about what reaches the deployed application. The relevant checks depend on the actual feature and architecture.

Start with the journey through your application

Follow a request from the browser through the server to storage and external services. At each transition, ask what information or authority crosses it. This is more useful than running a scanner and treating an empty report as completion.

For a first review, examine who may access each record, how runtime settings are controlled, how dependencies are selected, whether untrusted values can become commands, and what happens when a dependency fails. These are selected teaching examples, not a reproduction of the full official list or a complete assessment procedure.

Step-by-step process

  1. Choose one feature and its data

    Write down the user, operation, records and downstream services. Identify what is reachable without login and which actions become available after login.

  2. Ask access questions

    For each operation, specify who may perform it and on which records. Use separate test identities and synthetic records to check that disallowed operations are rejected by the server.

  3. Inspect settings and build inputs

    Review which configuration is public, where credentials are stored and how dependency changes are reviewed. A secret in browser code is available to the browser user.

  4. Check input and failure handling

    Review how the application treats untrusted input and unavailable services. A failed check should not silently grant access or trigger an unintended action.

  5. Record findings and choose deeper verification

    For each concern, record the feature, expected behaviour, evidence and next action. Use a scoped verification standard or specialist assessment where more depth is needed.

FOLLOW ONE EXAMPLE

Worked scenario

A portal that hides a button but still permits the action

In an authorised test environment, a fictional portal hides a document-delete button from a read-only test account. The underlying operation must also enforce that restriction.

  1. Document the expected behaviour: the read-only identity must not delete any record, regardless of whether the interface displays the button.
  2. Use the application’s approved test tooling to exercise the operation with the isolated test identity and synthetic data. Check the server’s decision and resulting record state.
  3. If the operation is allowed, treat it as a server-side permission defect. Repair and retest the operation rather than merely changing the interface again.

What this shows: A visible interface restriction is not evidence of an enforced permission rule. The review produces a specific defect or a recorded passing check.

The process at a glance

Check the actual server decision using authorised test identities. Hiding an action in the interface is not a substitute for enforcing its permission rule.
ProcessDecisionHuman checkpoint
Read Mermaid diagram source
flowchart TD
 A[Choose a web feature] --> B[Describe expected permissions]
 B --> C[Run authorised checks with test data]
 C --> D{Server enforces the rule?}
 D -->|Yes| E[Record evidence and scope]
 D -->|No| F[Repair the permission check]
 F --> C

What you should have at the end

  • A feature-level set of security questions.
  • Evidence of server-side permission checks and relevant failure behaviour.
  • A prioritised list of findings rather than a claim that a risk list is a certificate.

Common mistakes and how to avoid them

Using an old category list without naming the edition

State the reference version and consult its current official pages.

Assuming login proves permission for every operation

Identity and permission are separate decisions.

Treating a scanner result as a full review

Automated tools cover particular checks; application-specific rules still need investigation.

APPLY THE IDEA

Try it yourself

Your task: Select one read-only feature in your own test environment. Describe the allowed operation, a disallowed operation and the data involved.

What to produce: A review note with expected behaviour, authorised test method, result and next action.

Check your understanding: Does the evidence concern the server’s decision and actual data, rather than the appearance of a button?

Key terms in plain English

Authentication
Establishing which identity is making a request.
Authorisation
Deciding whether that identity may perform a particular operation.
Dependency
A component the application or build relies on.
Finding
A documented observation that requires a security decision or correction.

Sources and further reading