Keyboard navigation. Every interactive element must be reachable and usable via keyboard. Test by unplugging your mouse.
Color contrast. Text needs 4.5:1 contrast ratio against background. Large text needs 3:1. Use contrast checking tools.
Alt text for images. Describe what the image communicates, not just what it depicts. Decorative images get empty alt text.
Form labels. Every input needs a visible label. Placeholder text isn't sufficient.
What doesn't matter:
Perfect WCAG 2.2 AAA compliance. AA is the standard. AAA adds little value for most sites. Focus on basics first.
Mobile First Isn't Optional
60% of web traffic comes from mobile devices. That percentage increases every year.
Building for desktop first, then adapting for mobile, produces suboptimal mobile experiences. The constraints are different. Touch targets, screen size, connection speed, input methods.
What matters:
Touch targets minimum 48x48 pixels. Fingers are larger than mouse cursors. Small buttons frustrate users.
Readable text without zooming. Base font size 16px minimum. 18-20px for body text improves readability on small screens.
Simple navigation. Hamburger menus work, but consider alternatives. Too many options overwhelm small screens.
Test on actual devices. Simulators don't capture real behavior. Network conditions, touch accuracy, and screen quality differ.
What doesn't matter:
Pixel-perfect identical appearance across devices. Responsive design means adapting to context. Mobile layouts should differ from desktop.
Code Quality Compounds
Technical debt accumulates slowly, then cripples development velocity.
Clean code matters because you'll maintain this project for years. Six months from now, you won't remember why you wrote that clever hack.
What matters:
Consistent naming conventions. Pick a style. Stick to it. Consistency reduces cognitive load.
Component modularity. Each component does one thing. Smaller components are easier to test, reuse, and understand.
Documentation for complexity. Document why, not what. Code shows what it does. Comments explain why it does it.
Version control discipline. Clear commit messages. Atomic commits. Branches for features. This becomes critical when debugging months later.
What doesn't matter:
Perfect abstraction. Over-engineering for flexibility you might need someday creates complexity you definitely don't need today.
SEO Requires Structure
Search engines can't rank what they can't understand. Modern SEO isn't about keywords. It's about structure and meaning.
What matters:
Semantic HTML. Search engines use heading hierarchy to understand content structure. Skip heading levels confuses crawlers.
Meta descriptions. Don't determine ranking, but do affect click-through rate. Write for humans, not algorithms.
Page speed. Core Web Vitals are ranking factors. Slow sites rank lower, independent of content quality.
Mobile usability. Google uses mobile-first indexing. Mobile experience determines desktop ranking.
Schema markup. Structured data helps search engines understand content type. Rich snippets improve visibility.
What doesn't matter:
Keyword density. Modern search algorithms understand context and meaning. Writing naturally produces better results than keyword stuffing.
Choose Technology for Maintenance
The best framework is the one your team can maintain long-term.
Cutting-edge technology sounds appealing. But when something breaks in production at 2am, you need stable, well-documented tools with active communities.
What matters:
Community size. Large communities mean more tutorials, more Stack Overflow answers, more third-party packages.
Documentation quality. Official docs should answer common questions without requiring deep dives into source code.
Hiring pool. Obscure technologies limit who can work on your codebase. This becomes expensive.
Stability. Major breaking changes every six months create maintenance burden. Mature, stable platforms reduce long-term cost.
What doesn't matter:
Being on the cutting edge. Proven technology outperforms experimental technology for production work.
Security Isn't Optional
Security breaches cost money, reputation, and trust. Basic security practices prevent most attacks.
What matters:
HTTPS everywhere. No exceptions. Browsers flag HTTP sites as insecure. Users notice.
Input validation. Never trust user input. Sanitize everything. SQL injection and XSS remain common because developers skip validation.
Authentication best practices. Hash passwords properly. Use established libraries. Don't roll your own crypto.
Dependency updates. Vulnerabilities appear in dependencies regularly. Keep everything updated.
CORS configuration. Overly permissive CORS creates security holes. Configure precisely.
What doesn't matter:
Security theater. Obscuring source code, blocking right-click, or disabling dev tools doesn't improve security. It just annoys users.
Build Systems Should Fade
Build tools exist to solve problems. When build configuration becomes more complex than application code, something went wrong.
What matters:
Fast builds. Development iteration speed determines productivity. Waiting 30 seconds for builds kills flow.
Reliable builds. Builds should produce identical results every time. "Works on my machine" isn't acceptable.
Minimal configuration. Sensible defaults reduce maintenance burden. Configuration should handle edge cases, not common patterns.
Clear error messages. Cryptic build errors waste hours. Good tools explain what broke and how to fix it.
What doesn't matter:
Custom build pipelines showing technical sophistication. Standard configurations work fine and reduce maintenance cost.
Testing Prevents Regressions
Tests catch bugs before users do. But not all tests provide equal value.
What matters:
Integration tests. Test real user workflows. These catch bugs that unit tests miss.
Visual regression testing. Automated screenshots catch unintended layout changes.
Performance testing. Track load times, bundle sizes, and Core Web Vitals. Prevent performance regressions before they ship.
Accessibility testing. Automated tools catch 20-30% of accessibility issues. Manual testing catches the rest.
What doesn't matter:
100% code coverage. High coverage doesn't guarantee quality. Focus on testing critical paths and complex logic.
Standards Over Clever Solutions
Web standards exist for reasons. Browser vendors invest massive resources in optimization. Using standard features taps into that work.
What matters:
Native HTML elements.
