Static vs dynamic analysis
Static analysis reads code; dynamic analysis runs it. A static analyzer parses a file into an abstract syntax tree (AST) and checks that structure against rules — no server, no test data, no execution environment required, which is why it can run in seconds against a codebase that has never been deployed. Dynamic analysis (tests, fuzzers, DAST scanners) observes actual runtime behavior — what a function returns for a given input, how a running server responds to a crafted request — which static analysis cannot see by definition, since nothing executes. Neither replaces the other; they answer different questions.
What static analysis actually checks — beyond security
Security dominates the marketing, but static analysis is a general technique for checking any structural property of code. StaticCodeAudit's 708 rules span these categories:
Security
SQL injection, XSS, SSRF, path traversal, hardcoded secrets, insecure deserialization, weak cryptography, command injection, LDAP injection, insecure cookies, GDPR compliance patterns.
Architecture
Admin route protection, database logic embedded in routers, direct unparameterized queries, N+1 query patterns, oversized files.
Interface / UI
Inline styles, manual createElement usage, event listener leaks, DOM manipulation inside loops.
Accessibility / UX
Missing ARIA labels, missing alt text, focus management, autoplay misuse, i18n issues, toast/notification patterns, leftover console.log calls.
Maintenance
Unresolved TODO/FIXME/HACK/XXX markers, deprecated APIs, catch-all exception handling, debug statements, error suppressors.
Dependencies
Known-CVE scanning against installed packages (pip-audit, npm audit equivalents), unpinned version ranges, license compliance.
CI/CD
GitHub Actions and GitLab CI misconfiguration, expression injection, excessive workflow permissions, unpinned third-party actions.
How findings map to published standards
A finding without a standard reference is just an opinion. StaticCodeAudit tags every rule to at least a CWE identifier (MITRE's weakness taxonomy) or a WCAG 2.1 success criterion, and layers OWASP Top 10, ISO/IEC 27001 Annex A, OWASP ASVS v5.0 and NIST CSF 2.0 mappings on top where applicable — so a finding is traceable to an external, auditable reference rather than a vendor-invented severity label.
See the full standards coverage →Frequently asked questions
Is static code analysis the same as SAST?
SAST (Static Application Security Testing) is static analysis scoped specifically to security vulnerabilities. Static code analysis is the broader technique — the same parsing-and-rule-matching mechanism applies to architecture, accessibility, maintainability and dependency checks, not only exploitable vulnerabilities. See the dedicated SAST guide for the security-specific use case.
Can static analysis catch bugs that only appear at runtime?
Not directly — anything that depends on actual input values, timing, or environment state at runtime is outside what static analysis can observe by definition. Taint analysis narrows this gap by tracing how untrusted data could flow through code without running it, but it is inference, not observation. That is what dynamic testing is for.
Why does StaticCodeAudit cover UI and accessibility, not just security?
Because the underlying technique — parse the code, check the structure against rules — applies equally well to a missing ARIA label or an inline style as it does to a SQL injection pattern. Accessibility specifically also has growing regulatory weight (the European Accessibility Act 2025, for instance), which is why WCAG 2.1 mapping sits alongside CWE mapping rather than being a separate product.
How does static analysis avoid false positives?
It doesn't avoid them entirely — no static analyzer does, since it reasons about code structure without full runtime context. What varies enormously between tools is the false-positive rate, which depends on rule design (pattern-only rules are noisier than taint-tracking ones) and how conservatively a rule is scoped. Ask for a published, reproducible benchmark rather than a vendor's self-reported number — see real precision/recall benchmarks.
Does static analysis need the code to compile?
It depends on the tool. Some engines require a full build to construct a queryable database (common for deep semantic analysis of compiled languages). StaticCodeAudit does not — it parses source files directly with no build step, for any of its 8 supported languages, including compiled ones like Java and C#.
See what full-spectrum static analysis looks like
Open the live demo report — security, architecture, UI, accessibility, maintenance, dependencies and CI/CD findings, all in one HTML file.
Open the live report See the standards mapping