Application Security Checklist for 2026

Review server-side authorization, secret handling, browser protections, dependencies, and deployment settings against the application’s requirements. Use this checklist as a starting point; passing it does not establish that every risk has been addressed.
For apps built with Cursor, Windsurf, Lovable, or other tools, inspect the generated implementation and its deployment. Working features do not establish correct permissions or safe handling of untrusted input.
What Should an Application Security Checklist Cover?
Define the application’s assets, intended users, trust boundaries, and sensitive operations before selecting tests. Inspect generated code and deployment configuration independently of whether the visible features work.
This checklist covers eight essential domains:
- Authentication and Access Control
- API Keys and Secrets Management
- Database Security (RLS and Rules)
- Security Headers and CSP
- Injection and Input Validation
- Dependency and Supply Chain Security
- Monitoring, Logging, and Uptime
- Deployment Hygiene and Environment Security
Adapt the checks to each feature and record the evidence for its intended behavior and rejected abuse cases. Automated checks and manual review have different coverage limits.
1. How Do You Secure Authentication and Access Control?
Review object-level access, role changes, and administrative actions. A hidden button or client-side redirect does not enforce a server permission.
- Server-Side Authorization: Define and enforce the access policy for each endpoint, including intentionally public operations.
- Object-Level Checks: Test that changing a resource identifier cannot bypass required permissions.
- Password Storage: Use a maintained password-hashing implementation with suitable parameters; prefer Argon2id where supported. Never store plaintext passwords.
- Session Management: Protect session credentials and test expiration, logout, and revocation behavior. HttpOnly and Secure cookies have useful protections but also require appropriate CSRF controls.
- Rate Limits: Test abuse controls on
/login,/signup, and/reset-password; rate limiting does not prevent every attack. - MFA: Apply MFA and recovery controls appropriate to privileged accounts.
2. Are Your API Keys and Secrets Actually Secret?
A secret included in a browser-delivered main.js file is readable by visitors. A .next directory can contain both server and client artifacts; inspect what is actually served rather than assuming the directory name determines exposure.
- Built Assets: Search deployed files for patterns such as
sk_,key-, orAIza; investigate whether each match is actually a secret. - Environment Scope:
NEXT_PUBLIC_andVITE_can expose referenced values through their build systems. Other names can still leak through code or configuration. - Repository Handling: Ignore secret-bearing
.envfiles with appropriate.gitignorerules. Ignore rules do not remove tracked history. Revoke exposed credentials and investigate access. - Provider Calls: Keep secret provider credentials server-side and protect the proxy with authentication, authorization, validation, and usage limits.
- Rotation: Set rotation and revocation procedures for the actual credential type and risk.
Check your repo for leaks with our secret scanner or read the environment variables security guide.
3. Is Your Database Protected at the Database Layer?
Database access depends on the service and access path. PostgreSQL privileges and RLS, Firebase Security Rules, and application API authorization are different controls; none should be described as a universal substitute for the others.
- PostgreSQL Access: Review table privileges, RLS state, applicable policies, and bypass roles. Enabled RLS with no applicable policies denies access to subject roles.
- Operations: Test intended
SELECT,INSERT,UPDATE, andDELETEpermissions; policies can be separate or shared where appropriate. - Identity: Supabase’s
auth.uid()and Firebase’srequest.auth.uidbelong to different systems. Check authentication state and the intended resource permission in each. - Server Credentials: Keep
service_roleand other privileged credentials out of frontend code; they may bypass client access rules. - Function Resolution: Review
search_path, trusted schemas, and qualified object names for PostgreSQL functions, especially privileged functions.
For deeper dives, see the Supabase security checklist or the Firebase security checklist.
4. Which Security Headers and CSP Rules Do You Need?
Response headers can enable specific browser protections. Select them for the response type and test their behavior; their presence alone does not establish security.
- CSP:
default-src 'self'is a starting directive, not a complete strict policy or an XSS guarantee. Review scripts, nonces or hashes, and other relevant directives. - HSTS: Test
Strict-Transport-Securityand choosemax-agefor a prepared HTTPS deployment. A value such as31536000is an example, not a universal requirement; first visits and preload policy need separate consideration. - Content Types: Send the correct type and use
nosnifffor supported browser protections. - Framing:
DENYorSAMEORIGINcan restrict framing of applicable document responses; evaluate the application’s embedding needs. - CORS:
Access-Control-Allow-Origin: *can suit non-credentialed public resources. Use intended explicit origins for private browser access and enforce server authorization and CSRF defenses separately.
Inspect returned headers with the Security Headers Checker, then test the relevant browser behavior.
5. How Do You Prevent Injection and Validate Input?
Review the paths where untrusted input reaches queries, commands, or browser output. Schema validation, query parameters, output encoding, and HTML sanitization address different parts of that flow.
- Queries: Bind untrusted values as parameters and review ORM raw-query paths. Allowlist any variable query structure.
- Validation: Validate relevant inputs on the server, with resource and size bounds.
- HTML: Use context-appropriate output handling. If user HTML is required, apply a maintained sanitizer and avoid unsafe mutations afterward.
- Dangerous APIs: Avoid untrusted input reaching
eval()ornew Function(). ReviewdangerouslySetInnerHTMLand the sanitization of any HTML supplied to it; sanitizing HTML is not a general defense for code execution. - Uploads: Check type, size, storage, access, and serving behavior. File signatures alone do not prove a file safe, and size limits do not prevent every denial-of-service attack.
6. Are Your Dependencies Introducing Vulnerabilities?
Review the packages in node_modules, their provenance, and how the application uses them. A reported vulnerability’s impact depends on the affected version and reachable behavior.
- Audits: Use supported dependency checks such as
npm auditoryarn audit, and investigate findings against your release policy. A clear audit does not prove the absence of vulnerabilities. - Lockfiles: Commit the appropriate
package-lock.jsonoryarn.lockand use reproducible installation settings; a lockfile does not certify an audited build. - Pruning: Remove unused dependencies where feasible.
- Generated Suggestions: Verify the identity, provenance, and suitability of packages suggested by Cursor, Windsurf, or other tools.
7. What Should You Monitor and Log After Launch?
Monitor observable failures and security-relevant events, and define who investigates alerts. Monitoring can miss events or detect them after users are affected.
- Uptime Monitoring: Use uptime monitoring to detect availability failures and alerts to investigate changes. It does not prevent outages or establish that security controls are working. See uptime monitoring.
- Centralized Logging: Send server errors and security events (like failed logins) to a central service (e.g., Sentry, Logtail).
- Audit Trails: Log administrative actions · who changed a permission, who deleted a record, and when.
- Alerting: Set up Slack or Email alerts for critical errors or spikes in 401/403 response codes.
- No PII in Logs: Ensure that passwords, credit card numbers, and PII are scrubbed from logs before they leave your server.
8. Is Your Deployment Hygiene Up to Standard?
Review the hosting environment, deployment configuration, and exposed files. Record the checks and unresolved limitations.
- HTTPS: Configure HTTPS and intentional HTTP handling. Redirects do not protect a sensitive request already sent over plaintext HTTP.
- Environments: Separate production credentials and access from development and staging.
- Debugging: Set
NODE_ENV=productionwhere the framework uses it, and independently inspect error responses and logging. - Files: Test unintended public access to
.git,.env, anddocker-compose.yml. The Exposed Files Scanner runs bounded probes, not a complete inventory. - Reporting: A
security.txtfile under/.well-known/can publish reporting contacts; it does not secure the application. See the guide.
Audit, Hardening, or Risk Assessment: Which Checklist Do You Need?
While these terms are often used interchangeably, they serve different stages of the security lifecycle:
- Audit: Assess evidence against defined requirements and record gaps; a checklist is not proof that every control works.
- Hardening: Reduce avoidable exposure and strengthen configuration, whether or not an audit found the issue first.
- Risk Assessment: Evaluate likelihood, impact, and context to prioritize action. A missing
X-Content-Type-Optionsheader or exposed database needs investigation before assigning severity.
These live figures describe all scanned sites. They do not establish prevalence for an AI-built subgroup, compare development methods, or attribute findings to AI generation.
The average security score across the 125 live sites SimplyScan has scanned is 86 out of 100.
Automate repeatable checks and use manual review where context, permissions, or business logic require it. Record what each check covers.
Scan After Deployment Changes
Invoke the SimplyScan MCP server from a compatible client to run supported scans. A push does not trigger a scan unless your workflow is configured to do so.
Monitor Uptime and Health
Pro Monitoring includes Pro scan credits for full reports. See pricing for the allowance associated with your chosen option.
Set up Pro Monitoring for uptime alerts and scheduled rescans with change alerts. Investigate detected changes and coverage limits.
Use Standalone Tools
For quick checks, use our 60+ free tools, such as the JWT debugger or CORS tester.
SimplyScan’s free URL scanner grades observable security, speed, SEO, AEO, accessibility, compliance, domain, and email signals in about 30 seconds. It checks recognizable exposed secrets and supported anonymous backend observations; it does not verify all authentication logic or establish what other scanners miss.
Run a free security scan now
Application Security Checklist Template (Markdown)
Adapt this starting template in your SECURITY.md or issue tracker, adding application-specific requirements and evidence:
- [ ] **Auth**: Access policy tested for each sensitive API operation.
- [ ] **Auth**: Abuse controls tested on authentication endpoints.
- [ ] **Secrets**: Built client assets checked for secret credentials, including `dist/`.
- [ ] **Secrets**: Exposed credentials revoked; replacements stored server-side.
- [ ] **Database**: Applicable privileges and access rules tested with intended roles.
- [ ] **Headers**: Browser protections configured and tested for relevant responses.
- [ ] **Input**: Relevant inputs validated and interpreter/output paths reviewed.
- [ ] **Input**: Untrusted data kept out of `eval()` and unsafe `innerHTML` use.
- [ ] **Deps**: `npm audit` findings investigated; appropriate lockfile committed.
- [ ] **Logging**: Relevant events recorded and alert handling tested.
- [ ] **Deploy**: HTTPS behavior and unintended `.env` and `.git` exposure tested.FAQ
What is the difference between a security audit checklist and a vulnerability assessment checklist? An audit assesses evidence against defined requirements. A vulnerability assessment looks for weaknesses within a stated scope. Neither proves that all requirements are met or all vulnerabilities found. SimplyScan supplies bounded URL observations that can inform a review, alongside other tests and evidence.
How often should you run an application security checklist? Review security-relevant changes before release and test the deployed behavior afterward. Choose recurring reviews based on application risk, dependencies, and operational changes. Automated checks complement manual review; a schedule does not guarantee breach prevention.
Does an endpoint security checklist mean API endpoints or devices?
In the context of application security, "endpoint" refers to your API routes (e.g., /api/v1/user). An endpoint security checklist helps review authentication, rate limits, and input validation on these routes. In corporate IT, "endpoint security" refers to protecting physical devices like laptops and servers from malware.
What standards should an application security checklist be based on? Use OWASP ASVS to select applicable technical verification requirements and the OWASP Top 10 as a risk-awareness resource. Add controls for the services actually used, such as PostgreSQL privileges and RLS, Firebase Security Rules, and server-side secret handling.
Is an application security checklist different for AI-generated apps? The application still needs requirements for permissions, secrets, input handling, dependencies, and deployment. Review generated code and any suggested packages directly. Test actual behavior rather than inferring security from whether the code was generated or manually written.
What should a security testing checklist include before launch?
Test sensitive-operation authorization, applicable database rules, secret handling, input and output controls, browser protections, and deployment. Investigate automated findings and record untested areas. A reporting contact in security.txt and a completed scan do not establish that the application is secure.
31% of the 125 live sites SimplyScan has scanned (39 sites) have at least one high or critical security issue.
Frequently asked questions
Is your app secure? Run a free security scan in 30 seconds · no signup required.
Scan your app free →