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

A Web Application Security Checklist for Founders

TB
ThynkBlox Team
Engineering

A useful web application security checklist covers authentication, access control, input handling, secrets, dependencies, backups and logging. For each area, ask what protection you need, how it will be tested and what evidence you should review before launch. Use the checklist below to turn “we have handled security” into specific acceptance criteria.

What should founders ask to see before launch?

Start with the information your product holds and the actions users can take. List what must stay private, who may change it and what you would need to recover after a mistake.

Use those answers to guide this review:

AreaAcceptance questionEvidence to request
AuthenticationCan users sign in, recover access and end sessions safely?Demonstration of normal and rejected attempts
Access controlCan each user reach only permitted records and actions?Tests across users, organisations and roles
Input handlingDoes the app handle unexpected input safely?Tests for forms, requests and uploads
SecretsAre credentials restricted and replaceable?Access review and replacement demonstration
DependenciesAre outside components reviewed and maintained?Component inventory and review record
BackupsCan the business recover usable data?Completed restoration exercise
LoggingCan important events be investigated without exposing private data?Sample records and an alert demonstration

Make each answer specific to your product. “Permissions tested” is too vague; “a member cannot export another organisation’s records” is reviewable.

How should authentication protect account access?

Authentication is the sign-in part of the checklist. Review the full account journey, including invitation, recovery, password changes and sign-out.

Ask your build partner to demonstrate these acceptance criteria:

  • Require an additional authentication factor for administrator accounts and agree where else it is needed.
  • For password-based accounts, use a maintained password-handling component with an appropriate password-hashing method.
  • Set limits on repeated sign-in and recovery attempts.
  • Make recovery links expire and stop working after use.
  • Define when sessions expire and how users revoke access from a lost device.
  • Require fresh authentication before sensitive account changes.
  • Ensure account recovery does not bypass the protections required during sign-in.

Test unsuccessful paths as carefully as successful ones. Try an expired recovery link, a reused invitation and access after sign-out. If an outside sign-in service is used, include its connection to your application in the review.

How should access control separate users and organisations?

Write a permission table before accepting the implementation. For every role, specify which records it may view, create, edit, export and delete.

Include ownership as well as role. A person may have permission to edit records within their organisation without having permission to edit the same kind of record elsewhere.

Ask for permission checks on the server for every protected action. Do not accept hidden buttons as the evidence.

Illustrative example: a shared workspace has an owner and a member. The owner manages invitations; the member edits assigned records. Test whether the member can submit an invitation request directly, open an unassigned record or change a request to name another workspace. Each attempt should be rejected without exposing the protected information.

Include downloads, search, bulk actions and background work. Also test what happens after a role is reduced or membership is removed.

What should happen to unexpected input?

Specify accepted input for each entry point: type, length, range and permitted format. Apply those rules on the server, alongside any checks that help users complete forms.

Request tests for:

  • Missing values, unexpected fields and excessively long text.
  • Invalid values sent directly to the application, bypassing the form.
  • Prices, roles or ownership details that users must not control.
  • Text displayed later in pages, messages or exports.
  • Uploads with unsupported content or misleading file names.

Ask the team to use parameterised database queries and output handling appropriate to where text appears. Where formatted user content is allowed, define the permitted formatting and sanitisation approach.

Agree upload rules explicitly: accepted content, size limits, access permissions and removal behaviour. Error messages should help users correct a problem without displaying private records, credentials or diagnostic details.

How should secrets and privileged access be handled?

Treat passwords, signing keys and service credentials as restricted assets. For each one, identify its purpose, who can access it and how it can be replaced.

Require these safeguards:

  • Keep secrets out of source code, browser-delivered code, screenshots and support messages.
  • Give each credential only the permissions required for its purpose.
  • Restrict who can view or change it.
  • Keep development credentials separate from those serving customers.
  • Document how to replace a credential and revoke the previous one.
  • Remove access when a person or supplier no longer needs it.

Ask for a replacement exercise using a non-customer credential. Confirm that the replacement works and the previous credential is rejected.

For the wider question of what information your product should collect and retain, see data security in modern applications.

What should founders expect for dependency security?

Ask for an inventory of outside libraries and services, with an owner for reviewing updates and security notices.

Set an acceptance rule for unresolved issues. Each should have an assessment of whether the application uses the affected behaviour, what action is needed and when it will be completed. A scanner report alone should not count as a decision.

Require the team to:

  • Remove components that are no longer used.
  • Review maintenance status before adding a dependency.
  • Check updates before they reach customers.
  • Assess notices against the application’s actual usage.
  • Record any accepted exception with a reason and review point.

Include inherited dependencies in the review. Ask how urgent updates will be handled after handover, including who tests them and who authorises release.

What makes a backup acceptable?

Define recovery needs in business terms. Agree how much recent work you could tolerate losing and how long you could operate without the application.

Then request a restoration exercise. Restore a backup into an isolated setting, open representative records and confirm that related files and relationships remain usable.

The acceptance checklist should cover:

  • Which records, attachments and settings are included.
  • Who can access, restore or delete backups.
  • How backup failures are reported.
  • How recovery works if normal administrator access is unavailable.
  • Who performs recovery and verifies the result.

Record what was restored, what was missing and how long the exercise took. Set a schedule for repeating it and repeat it after material changes to data storage.

What should logging and alerts cover?

Choose events based on decisions you may need to investigate. Include failed sign-ins, permission changes, administrator actions, sensitive exports and destructive operations.

For each event, agree what context is necessary: the acting account, attempted action, affected record, time and outcome. Exclude passwords, authentication tokens and unnecessary personal information.

Ask the team to demonstrate that:

  • Authorised people can investigate an important event.
  • Ordinary users cannot access the records.
  • Alerts reach someone responsible for responding.
  • Retention and deletion follow an agreed policy.
  • A failed alert delivery is detectable.

Test an alert from event to recipient. A configured destination is not enough evidence that somebody receives and understands it.

What common mistakes should founders avoid?

Accepting a checklist without evidence. Attach a test result, demonstration or review record to each important item.

Testing only the administrator account. Include ordinary users, removed members and attempts to cross organisation boundaries.

Treating a scan as the entire review. Ask separately about permissions, recovery and business-specific actions.

Leaving support arrangements undefined. Agree who receives reports, removes access and handles urgent fixes after launch.

Treating launch approval as permanent. Revisit the checklist when roles, integrations, uploads or sensitive workflows change.

Use the OWASP Top 10 as a well-known list to discuss with your build partner. Keep your acceptance criteria tied to your product. For more on asking for meaningful verification, read software testing and quality assurance practices.

What questions do founders commonly ask?

Does every application need the same controls?

Keep the same review areas, but adjust the requirements. A public information site and a private customer workspace need different permission and recovery tests. Record why an item does not apply instead of silently skipping it.

Is this checklist a security certification?

No. Use it to define requirements and review evidence. Agree whether the product also needs an independent assessment, contractual review or specialist advice.

What if we use managed authentication?

Review the account journey and application permissions anyway. Ask which responsibilities the provider handles and which remain with your build partner.

What should block launch?

Define blockers before the final review. Include unresolved failures that allow unauthorised access, expose secrets or prevent an agreed recovery exercise from succeeding. Any exception should name a decision-maker, a reason and a resolution point.

For timing and scoping an external assessment, see when your software needs a penetration test.


*Need help reviewing the security requirements for your web application? Start a conversation.*

Ready to build?

Let's turn these ideas into your next product.

Start your project