Executive Overview
For decades, the standard procedure for building a JavaScript application began with a routine step: reaching for npm. Need to format a relative date? Install timeago.js. Need to group an array or perform a deep clone? Pull down Lodash functions. Building a modal or tooltip? Reach for tippy.js, focus-trap, or a11y-dialog.
Once installed, these dependencies quietly faded into the background. Tests passed, builds succeeded, and developers moved on. Over time, however, a profound shift has occurred beneath the surface of the web ecosystem. The gap between what developers need a library for and what the native browser can do has narrowed dramatically.
Today, a typical mid-sized JavaScript application carries between 60KB and 90KB (minified and gzipped) of third-party dependencies that modern web browsers can now handle natively. Driven by coordinated efforts like the WebDX Community Group’s "Baseline" initiative, modern web platforms are shipping powerful, standardized APIs at an unprecedented cadence.
Yet, most engineering teams continue to run npm audit exclusively for security vulnerabilities, rarely asking a more fundamental question: Is this library still performing a task the browser can handle on its own? This article explores a practical, data-driven framework for auditing your dependencies, reclaiming your bundle size, and safely leaning into the modern web platform.
Detailed Chronology & The Shift Toward Native Capabilities
To understand how we arrived at an era where native browser APIs can replace standard npm packages, we must examine the historical trajectory of web development.
The Era of Polyfills and Fragmented Engines
In the early 2010s, JavaScript engines (V8, SpiderMonkey, JavaScriptCore) had disparate feature sets, and standardization was sluggish. Simple tasks like string formatting, deep object cloning, network requests, and structural UI management (such as accessible dialogs or tooltips) required robust userland libraries. Frameworks and utility belts like jQuery, Underscore, and later Lodash, along with heavy HTTP clients like Axios and granular date-manipulation utilities like Moment.js, became foundational pillars of web architecture.
The Rise of Modern Standardization
As the TC39 committee accelerated ECMAScript updates and browser vendors synchronized their release cycles, the landscape fundamentally shifted. The introduction of the Fetch API standardized network requests; Intl objects brought robust internationalization directly to the runtime; and layout primitives like the native <dialog> element and the Popover API reimagined UI engineering.

The Catalyst: The Baseline Initiative
The turning point for confident platform adoption arrived with Baseline, an initiative spearheaded by the WebDX Community Group. Baseline provides a clear, transparent metric for feature readiness across major browser engines (Chrome, Edge, Firefox, and Safari).
Baseline categorizes features into two essential states:
- Newly Available: Supported across all major browser engines, marking the beginning of a feature’s lifecycle.
- Widely Available: Having cleared a critical 30-month window of support across all mainstream engines, making the feature safe to use universally without polyfills or defensive checks.
This chronological shift means that developers no longer have to guess whether an API is safe to deploy in production. By mapping dependencies against Baseline statuses, teams can systematically prune redundant code.
Supporting Context & Metrics: Auditing the Clusters
Instead of analyzing dependencies in isolation, engineering teams achieve the highest efficiency gains by auditing in thematic clusters. Wins naturally compound when evaluating functional groups.
Cluster 1: Internationalization (The Immediate Low-Hanging Fruit)
Historically, formatting dates, numbers, and lists required heavy utilities. Today, the browser’s native Intl namespace handles these requirements natively and with superior localization support.
- Relative Time:
timeago.jscan be replaced byIntl.RelativeTimeFormat(Baseline Widely Available). By combiningIntl.RelativeTimeFormatwith a lightweight arithmetic helper to determine the appropriate unit, developers eliminate an entire dependency. - Numbers, Currency, and Lists:
Intl.NumberFormatreplaces numeral libraries for compact notations, currency styling, and separators, whileIntl.ListFormatnatively generates natural language lists with proper conjunctions and Oxford commas. - The Caveat — Durations: While
Intl.DurationFormatreplaceshumanize-duration, it is currently classified as Newly Available (having landed across major engines in early 2025). B2B or internal applications can adopt it immediately; consumer-facing products with legacy user bases require feature detection or a temporary fallback.
Impact: Pruning the internationalization cluster typically recovers roughly 14 KB gzipped from the production bundle.
Cluster 2: HTTP Clients
Libraries like axios (~17 KB gz) and superagent (~19 KB gz) have long been staples for API communication. However, modern native primitives—specifically fetch paired with AbortController and AbortSignal.timeout()—handle standard data-fetching operations natively.

While fetch lacks built-in features like request interceptors, automatic retries, or global transform maps out-of-the-box, many applications only utilize basic GET and POST requests. For teams relying solely on standard operations, migrating to a thin, custom wrapper around fetch slashes approximately 17 KB gzipped of redundant abstraction overhead.
Cluster 3: UI Primitives & Accessibility
Historically, modal dialogs, focus trapping, body scroll locking, and popovers required complex third-party packages to guarantee accessibility compliance. The web platform now offers native equivalents that often exceed the quality of hand-rolled scripts:
- The
<dialog>Element: Widely available,dialog.showModal()automatically handles focus trapping, background inertness,Escapekey handling, and rendering in the browser’s top layer. - The Popover API & CSS Anchor Positioning: Combined with the Popover API (light-dismiss and top-layer rendering) and CSS anchor positioning (which anchors floating tooltips and menus dynamically without JavaScript calculations), developers can safely remove libraries like
tippy.js,focus-trap, andbody-scroll-lock.
Impact: Eliminating this UI primitive cluster recovers roughly 24 KB gzipped while improving accessibility defaults.
Cluster 4: Lodash Utilities
While full Lodash imports are less common in modern tree-shaken builds, cherry-picked utilities like lodash.clonedeep and lodash.groupby remain prevalent.
- Grouping:
Object.groupByandMap.groupBynatively group array elements into objects or maps. - Deep Cloning:
structuredClone()is widely available and safely clones complex data structures (including Dates, Maps, Sets, and circular references) without pulling in external utility code. - Set Operations: Native
Setprototypes now support built-in mathematical operations includingintersection,union,difference, andsymmetricDifference.
Impact: Removing redundant Lodash sub-packages saves 8 KB gzipped or more, streamlining runtime execution.
Official Statements and Industry Perspective
As the web ecosystem embraces native capabilities, software architects and standards bodies emphasize a balanced approach to dependency management.
Industry leaders point out that the goal of leveraging Baseline is not to eliminate third-party code recklessly, but to align engineering practices with the capabilities of the modern web platform. As noted by core platform contributors in web-standards communities:

"The web platform is no longer a static document renderer; it is a rich application runtime. When developers continue to ship polyfills and abstraction layers for features the browser has natively optimized, they pass an unnecessary performance tax onto their users—manifesting as slower parse times, bloated bundles, and increased main-thread execution cost."
At the same time, standards bodies urge caution against premature optimization. Pruning dependencies must always be weighed against the unique demographic profile of an application’s user base. A framework of progressive enhancement ensures that modern users benefit from lean, native APIs, while edge cases are handled gracefully through defensive checks or conditional polyfilling.
Future Outlook: What Lies Ahead on the Horizon
Looking forward, the roadmap for the web platform indicates that the boundary between application frameworks and native browser capabilities will continue to blur. Several upcoming standards promise to eradicate even more complex userland dependencies over the coming years:
- Temporal API: Poised to completely replace legacy
Dateobjects and third-party libraries likemomentordayjs, Temporal offers immutable dates, native time-zone support, and intuitive parsing. Though currently navigating the final stages of stable multi-engine rollout (with Safari adoption underway), it represents the future of native time management. - Advanced CSS Anchoring and Scroll-Driven Animations: As anchor positioning features mature and scroll-driven animations become fully ubiquitous, heavy JavaScript-based layout and animation libraries will become increasingly obsolete for standard UI interactions.
- Signal-Based Reactivity: Discussions around native reactivity primitives within JavaScript engines continue to evolve, signaling a long-term architectural alignment between runtime capabilities and modern frontend paradigms.
A Repeatable Framework for Your Team
To capitalize on these advancements, engineering teams should institutionalize a quarterly audit routine:
- List Production Dependencies: Run
npm ls --omit=dev --depth=0to identify active user-facing packages. - Measure Real Bundle Costs: Utilize tools like Bundlephobia or source-map explorers to evaluate true minified and gzipped sizes.
- Evaluate Baseline Status: Cross-reference replacement platform features against
webstatus.devor MDN documentation. - Apply the Three-Question Filter: Verify audience safety, calculate swap costs, and ensure platform features cover actual use cases.
- Implement Progressively: Deploy native features using feature detection where appropriate to protect legacy user experiences.
By treating dependency management as a living, cyclical process rather than a one-time setup decision, organizations can systematically reduce bloat, accelerate page load performance, and build more resilient, maintainable web applications.
