getty
Modern web development is faster and more powerful than ever, thanks to JavaScript frameworks, cloud services, AI-assisted coding tools and increasingly sophisticated tech stacks. But as teams race to ship new features and lean on layers of automation and abstraction, some foundational web development practices can start to look outdated or optional.
That can be a risky assumption. Many of these long-standing disciplines still shape how websites and web applications perform, protect users, remain accessible and hold up when real-world conditions aren’t ideal. Below, members of Forbes Technology Council share the web development practices they believe teams should keep prioritizing, even as tools and technologies continue to evolve.
Testing like a skeptic is important. Frameworks and AI now produce code that looks right instantly, so teams assume rigorous testing is handled. But when the same model writes the code and its tests, the tests inherit the code’s blind spots and confirm the bug. What still matters: a human deciding what to test and which ugly edge cases to hunt. The machine can write the test. It can’t decide to doubt the code. - Andrew Siemer, Inventive
One web development practice that still matters deeply is building for graceful failure. Modern apps rely on countless APIs, scripts and integrations, but every added layer increases fragility. The strongest teams still ensure core user journeys work even when scripts fail, networks slow down or external services break, because resilience is what protects user trust. - Arun Goyal, Octal IT Solution LLP
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
Error state design is the practice most teams skip. When every critical journey depends on JavaScript, a single failed API call or blocked script can render a blank page to real users. Teams that design explicit fallbacks for every failure mode build products that earn trust. A framework cannot save you from a component that has no error boundary. - Manas Chaudhari, Meta
Strategic resource prioritization through manual hint tagging is often neglected in favor of automated framework bundling. Relying solely on a compiler to guess what is critical results in layout shifts and delayed interactivity. Explicitly managing the loading order of assets via preload and preconnect remains a vital lever for user retention. You cannot automate empathy for a user on a weak signal. - Jagadish Gokavarapu, Wissen Infotech
Basic caching strategy still matters more than many teams realize. Modern frameworks often refetch the same APIs and scripts repeatedly because “the frontend is fast enough.” It is not. Poor caching quietly increases latency, cloud cost, battery usage and backend load at scale. Smart cache headers, CDN usage and controlled invalidation still separate responsive systems from expensive ones. - Sibasis Padhi, Walmart Inc.
Understanding the underlying system still matters. Too many teams rely on layered abstractions, frameworks and AI-generated code without understanding what is actually happening underneath. When performance drops, security fails or integrations break, the issue is usually hidden below the abstraction layer. Convenience scales fast, yet technical depth still compounds value. - Doug Shannon
Modern frameworks are excellent at hiding complexity until that complexity hides a failure. The practice teams are quietly dropping is runtime observability: error boundaries and instrumentation that surfaces real problems before users report them. Logs tell you what crashed. They rarely tell you what the user experienced. That gap gets more expensive as framework layers multiply. - Maitrik Patel, Apple
One of the practices that still matters deeply is architectural simplicity. Modern frameworks make it easy to layer abstractions until systems become fragile, opaque and difficult to debug. The strongest engineering teams still optimize for clarity, predictable failure modes and minimal dependency chains because, at scale, complexity becomes both a performance risk and a business risk. - Shuchi Agrawal, SMBC Group
One essential practice is semantic HTML. Modern frameworks make it tempting to wrap everything in generic <div> tags. This can create problems because native tags like <nav> and <button> provide built-in accessibility and SEO that div soup can’t replicate. Screen readers and bots rely on these tags. Using a div for a button is just reinventing the wheel with more bugs. - Mahendran Chinnaiah
One web development best practice that still matters is designing for human usability and experience. While modern frameworks simplify development, applications must remain intuitive, accessible and engaging for diverse users. Technology evolves quickly, but a seamless user experience continues to drive adoption, trust and long-term product success. - Prashanthi Kolluru, KloudPortal Technology Solutions Pvt Ltd.
A best practice that teams undervalue is progressive enhancement with strong HTML and answer engine optimization (AEO). Even with heavy JavaScript, semantic markup ensures accessibility, SEO relevance and answer-ready content for AI and search engines, making apps more discoverable, resilient and usable across devices and situations. - Hemant Soni, CAPGEMINI AMERICA INC.
Performance budgets still matter. Modern frameworks make it easy to add libraries, trackers and components until pages quietly balloon to multiple megabytes. Teams assume fast devices and 5G absorb it, but real users on mid-tier phones and weak networks bounce. Setting and enforcing budgets for bundle size, requests and Core Web Vitals keeps performance a design constraint, not an afterthought. - Nitin Agarwal, Luminace
Security basics still matter more than many teams realize. Even with modern frameworks, websites still need safe login methods, strong access controls, input checks and regular dependency updates. Hackers often exploit simple gaps, not just advanced flaws. Frameworks are powerful, but they should not replace the discipline of building secure foundations. - Salice Thomas, Wipro Limited
Error budgets for the frontend are important. Teams treat uptime as a backend concern and ship frontends with no tolerance threshold for failed scripts, slow renders or broken third-party tags. The result is silent degradation or dashboard catches. Set explicit budgets for client-side failures and alert on them. Users churn from friction long before they file a ticket. - Nidhi Jain, CloudEagle.ai
Page weight is the performance metric teams consistently overlook, assuming modern networks and CDNs will compensate for bloated JavaScript bundles and unoptimized assets. They don’t—particularly for users on mobile or constrained connections, where every extra kilobyte compounds into long load times, sluggish UX and, ultimately, lost engagement. - Kevin Cushnie, Modus Create
Discernment and critical thinking are scarce in the frontend world. That’s why there’s been a proliferation of npm packages that wrap 10 lines of code in a full-fledged package. Web apps don’t depend on frameworks and JavaScript. They delegate thinking and responsibilities. Start relying again on good engineering practices, knowledge of data structures and algorithms. - Victor Paraschiv, broadn
Clean, well-structured data architecture still matters more than most teams realize. Modern frameworks can create impressive experiences, but if the underlying data is inconsistent, duplicated or poorly governed, performance, personalization, AI and scalability all suffer. Great digital experiences are not built on interfaces alone. They are built on trusted, connected data. - Lori Schafer, Digital Wave Technology
Subresource integrity matters because as teams pull scripts from a CDN, they trust the provider and skip the hash that proves the file hasn’t changed. From a security perspective, that’s usually how a trusted third-party script becomes your breach. The Polyfill.io takeover showed it: one acquired domain, malware pushed to thousands of sites overnight, every framework rendering it flawlessly. An SRI hash is a few characters that block the load when the code isn’t what you approved. - Dan Sorensen, Nexus Security Advisors
A best practice that teams should not abandon is optimizing for performance before adding complexity. Modern frameworks can accelerate development, but excessive scripts and layers often reduce speed, accessibility and reliability. In mission environments, efficiency matters because overloaded systems increase risk. Fast, lightweight design still builds stronger trust and better long-term experiences. - Shelli Brunswick, SB Global LLC
Server-side rendering is a best practice we should still be talking about. Everyone thinks SPAs and client-side JS solved everything. Wrong. You’re shipping 5MB of JavaScript so users can read text. Insane. SSR matters for speed, SEO and accessibility—the fundamentals. Half the internet is broken on slow connections because devs forgot users don’t have M3 MacBooks. Optimize for the worst device, not your dev machine. Physics still wins. - Rishi Gupta, Infosys DX Consulting
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。