We live in an era where a simple tooltip pulls in 50KB of JavaScript. The modern web has become bloated not because browsers lack capability, but because developers stopped reading MDN. The truth is: modern browsers ship with incredibly powerful APIs that can replace most utility libraries.
The best dependency is no dependency.
Let us start with the Intersection Observer API. No more scroll event listeners calculating bounding rectangles. No more throttled scroll handlers eating main thread cycles. Just clean, performant observation of element visibility.
// Lazy loading images without a library
const imageObserver = new IntersectionObserver((entries, observer) => {
    entries.forEach(entry => {
        if (entry.isIntersecting) {
            const img = entry.target;
            img.src = img.dataset.src;
            img.classList.add('loaded');
            observer.unobserve(img);
        }
    });
}, {
    rootMargin: '50px 0px',
    threshold: 0.01
});

document.querySelectorAll('img[data-src]').forEach(img => {
    imageObserver.observe(img);
});
Next, the Resize Observer API. Forget polling window.innerWidth or fighting with media queries in JavaScript. Observe individual elements and react to size changes precisely. This is how modern dashboards and data visualizations should work.
// Responsive chart without resize listeners
const chartContainer = document.querySelector('.chart');

const resizeObserver = new ResizeObserver(entries => {
    for (const entry of entries) {
        const { width, height } = entry.contentRect;
        canvas.width = width * devicePixelRatio;
        canvas.height = height * devicePixelRatio;
        canvas.style.width = `${width}px`;
        canvas.style.height = `${height}px`;
        renderChart(width, height);
    }
});

resizeObserver.observe(chartContainer);
The View Transitions API deserves special mention. It enables smooth, morphing page transitions with a single line of JavaScript. No GSAP, no Framer Motion, no complex keyframe choreography. The browser handles the interpolation between DOM states.
// SPA-like transitions in a multi-page app
document.addEventListener('click', async (e) => {
    const link = e.target.closest('a[href^="/"]');
    if (!link) return;
    e.preventDefault();
    
    const transition = document.startViewTransition(async () => {
        const response = await fetch(link.href);
        const html = await response.text();
        const doc = new DOMParser().parseFromString(html, 'text/html');
        document.querySelector('main').innerHTML = doc.querySelector('main').innerHTML;
        history.pushState(null, '', link.href);
    });
    
    await transition.finished;
});
The performance implications are staggering. Removing dependencies means smaller bundles, faster parse times, and less memory pressure. But more importantly, native APIs are optimized by browser engineers who understand the rendering pipeline at a fundamental level. Your hand-rolled throttle function will never outperform the browser's internal scheduler.
The next time you reach for npm install, pause. Check if the platform already solved your problem. The web platform has never been more capable — we just stopped trusting it.