A web application is more than an interface. A good web app performs well, stays available, is accessible, secure and maintainable. Teams often prioritize one or two aspects and neglect the rest. That creates unhappy users and growing costs.
This article lists concrete criteria per topic, measurable signals and practical steps. For each criterion I point out what to measure, sensible targets and which choices affect time and budget. Where relevant I link to official guidance for performance, accessibility and security.
Five core criteria
- Performance: load times and interactions.
- Reliability: uptime, graceful degradation and scaling.
- Accessibility: WCAG compliance and keyboard support.
- Security: threat vectors and mitigations based on common lists.
- Maintainability: code quality, tests and CI/CD.
Performance
What to measure
- Largest Contentful Paint (LCP): time until the main visible element is painted. Good target: < 2.5s.
- Interaction to Next Paint (INP): responsiveness to user input.
- Cumulative Layout Shift (CLS): visual stability.
Use the Core Web Vitals guidance as an objective baseline: see Core Web Vitals and deeper pieces like LCP and INP.
Practical actions
- Prioritize critical CSS and fonts. Load non-critical JS asynchronously.
- Reduce server latency: caching, CDN, and optimized images.
- Measure with RUM and lab tools and set realistic budgets.
Estimated effort
- One-week optimisation sprint: roughly 800–2.500 EUR, depending on current issues.
Reliability
What matters
- Uptime and synthetic checks.
- Graceful fallback behavior when services fail.
- Load testing against expected peak traffic.
How to measure
- Combine synthetic monitoring with real-user monitoring.
- Define SLOs; e.g. 99.9% uptime as a baseline.
Engineering choices
- Prefer stateless services for autoscaling.
- Implement retries with backoff, circuit breakers for external calls.
Costs
- Basic monitoring tools cost roughly 50–300 EUR/month; enterprise setups are more expensive.
Accessibility
Why it matters
Accessibility increases reach and reduces legal risk. It often improves general UX as well.
Standards and testing
- Follow WCAG 2.2 guidelines: https://www.w3.org/TR/WCAG22/.
- Test keyboard navigation, screen readers, and contrast.
Concrete items
- Ensure contrast ratios meet SC 1.4.3.
- Make focus states visible and predictable.
- Provide programmatic labels for forms and clear error messages.
Estimated work
- Basic accessibility fixes: 1–3 weeks, 1.200–6.000 EUR. Full audits and remediation take more time.
Security
Start point
- Use the OWASP Top 10 as your baseline checklist: https://owasp.org/www-project-top-ten/.
- Apply server hardening, secure headers, input validation and rate limiting.
Practical steps
- Use parameterized queries or ORM features to prevent injection.
- Enforce strong auth: MFA for admin accounts, secure session management.
- Run dependency audits and automated security scans on CI.
Costs
- Baseline hardening: 800–4.000 EUR.
- External penetration test: 1.500–8.000 EUR depending on scope.
Maintainability
Key practices
- Modular code, clear documentation and API contracts.
- Automated tests: unit, integration and E2E for critical flows.
- CI/CD pipeline for reproducible builds and safe deploys.
Signals to watch
- Test coverage for key modules and lead time for changes.
- Time to recover from failures and frequency of hotfixes.
Organisation
- Schedule regular refactors and technical debt sprints.
- Maintain runbooks and rollback procedures.
Costs
- Maintenance contracts vary; 300–2.000 EUR/month is a common mid-size range.
Comparison table
Performance
- Metrics / Tools
- LCP, INP, CLS (Core Web Vitals)
- Practical target
- LCP < 2.5s; low INP; CLS < 0.1
Reliability
- Metrics / Tools
- Uptime, RUM
- Practical target
- SLO 99.9%+
Accessibility
- Metrics / Tools
- WCAG 2.2 tests
- Practical target
- AA compliance
Security
- Metrics / Tools
- OWASP Top 10
- Practical target
- No critical findings
Maintainability
- Metrics / Tools
- Tests, CI/CD
- Practical target
- Fast, repeatable deploys
| Criterion | Metrics / Tools | Practical target |
|---|---|---|
| Performance | LCP, INP, CLS (Core Web Vitals) | LCP < 2.5s; low INP; CLS < 0.1 |
| Reliability | Uptime, RUM | SLO 99.9%+ |
| Accessibility | WCAG 2.2 tests | AA compliance |
| Security | OWASP Top 10 | No critical findings |
| Maintainability | Tests, CI/CD | Fast, repeatable deploys |
Quick checklist for a new project
- Define business-critical user journeys and metrics.
- Set a performance budget and LCP target.
- Define SLOs and a monitoring plan.
- Schedule a WCAG baseline audit and prioritize fixes.
- Run dependency and security checks on every build.
- Implement CI/CD with automated tests and rollbacks.
- Reserve capacity for refactoring in each sprint.
- Agree on support and maintenance terms.
Hiring a developer or agency
When you want to have a web app built, check for demonstrable processes around performance and security. Ask how they track and improve metrics over time. If you need an agency, consider teams that also offer maintenance—this reduces context loss. For tailored projects search options like web app laten maken or bespoke work via maatwerk-software.
Note on costs: all figures are indicative and vary per scope.
If you want to discuss a concrete quote, request one at /quote.
Sources
Every figure and guideline in this article can be checked in the sources below.
- Core Web Vitals — web.dev (Google)
- Largest Contentful Paint (LCP) — web.dev (Google)
- Interaction to Next Paint (INP) — web.dev (Google)
- OWASP Top 10 — OWASP
- Web Content Accessibility Guidelines (WCAG) 2.2 — W3C
Got a project in mind?
Tell us briefly what you want to build. You get an honest read on scope, price and timeline within one business day.
Request a quoteRelated services
Continue on the page that matches this topic.
Keep reading
Other articles that pair well with this one.
