Check what you actually know
95 quizzes. Every answer explained as you go, with a reference — and no account needed.
Nuxt 4 Migration: The Breaking Changes That Actually Bite
Nuxt 3 reached end-of-life on July 31, 2026. Here's exactly what breaks moving to Nuxt 4 — directories, data fetching, TypeScript — plus a cheat sheet.
Take the quiz →
Your Lighthouse Score Is 100. Long Animation Frames Explain the Jank.
Lighthouse says 100 and CI is green, but a user still says the filter button feels sluggish. The Long Animation Frames API names the exact script and phase that blocked the frame — here's how to read it instead of squinting at a flame chart.
Take the quiz →
React 19.3 Fragment Refs: Skip the Wrapper Div for a Ref
React 19.3 Fragment Refs let you ref a sibling group with no wrapper div. Learn the FragmentInstance API, its limits, and get a copy-paste cheat sheet.
Take the quiz →
You Added will-change to Fix the Jank. You Made It Worse.
will-change: transform looks like a free performance switch. Applied broadly or left on permanently, it does the opposite — here's the narrow, temporary pattern that actually works.
Take the quiz →
You're Animating for Everyone. prefers-reduced-motion Fixes That.
Most animated UIs never check whether the visitor asked for less motion. `prefers-reduced-motion` is the CSS media feature that tells you — and a fail-closed pattern keeps you honest even when a browser doesn't support it.
Take the quiz →
Stop Losing Promise Errors. unhandledrejection Catches Them.
A rejected promise with no .catch doesn't crash and doesn't show up in your error tracker — it just disappears. The unhandledrejection event is the global safety net most apps never wire up.
Take the quiz →
Stop Retrying Immediately. Exponential Backoff Fixes It.
Retrying a failed fetch() right away feels responsible — until the server that failed was already overloaded, and five instant retries per client turn a blip into an outage. Exponential backoff with jitter is the fix.
Take the quiz →
I Built Cross-Tab Logout. The storage Event Skipped One Tab.
A cross-tab 'log out everywhere' feature built on the storage event worked in every tab except the one the user actually clicked in. The storage event never fires in the tab that made the change — and that's spec, not a bug.
Take the quiz →
Next.js Streaming Metadata: Why Your <head> Looks Incomplete
Next.js 16 streaming metadata sends users a page before generateMetadata resolves, but blocks crawlers for a complete head. How it works, plus a cheat sheet.
Take the quiz →
Vue defineModel: The v-model Contract, Explained
Vue's defineModel macro replaces the modelValue prop and update:modelValue event with one ref. The exact v-model contract behind it, verified against Vue 3.5.
Take the quiz →
beforeunload Can Still Kill Your bfcache. Mount It Only When Dirty.
A `beforeunload` listener you left mounted forever can still quietly cost you bfcache eligibility — and an `unload` listener reliably will. Here's the pagehide/pageshow fix, and why 'mount it only when there's something to lose' is the durable rule.
Take the quiz →
Nuxt 4.5 SSR Streaming: The Route Rules That Disable It
Nuxt 4.5's experimental SSR streaming flushes HTML early, but cache, isr, swr, redirect, and ssr:false route rules silently fall back to buffering. Cheat sheet included.
Take the quiz →
Stop Hand-Rolling an Exclusive Accordion. <details name> Does It
You've probably shipped an accordion with a hand-rolled 'close the other panels' loop in JavaScript. The `name` attribute on <details> does it natively — no JS, no ARIA plumbing.
Take the quiz →
React 19.3 ViewTransition: Animate State Without Losing It
React 19.3's ViewTransition component animates state changes, not just page swaps — the mental model, enter/exit/update/share, and a cheat sheet.
Take the quiz →
Your Search Box Lags. Debounce Hides It; useTransition Fixes It
A big list re-render was blocking every keystroke — debouncing just moved the freeze. useTransition tells React which update can wait.
Take the quiz →
NestJS 12: Standard Schema Validation Without class-validator
NestJS 12 adds Standard Schema validation for @Body(), @Query(), and @Param() — validate with Zod or Valibot, no class-validator DTO. Cheat sheet included.
Take the quiz →
Stop Fixing Headline Gaps With Negative Margins. Use text-box-trim
Line-height reserves space for accent marks your headline never uses — a hand-tuned negative margin only fixes it for one font at one size. text-box-trim does, natively, from the font's own metrics.
Take the quiz →
:nth-child(even) Counts Hidden Rows. of S Fixes Your Stripes
nth-child(even) counts every element in the DOM, including the ones you just hid with display:none. The fix isn't JavaScript — it's a CSS selector most people have never had a reason to use.
Take the quiz →
Vue computed(): What It Caches and When It Reruns
Vue's computed() caches its result and only reruns when a tracked dependency changes, not on every read. The exact caching and invalidation model, verified against Vue 3.5.
Take the quiz →
Your backdrop-filter Is Working. Your Background Is Hiding It.
backdrop-filter looks like a one-line copy from a Codepen: blur(20px), ship the frosted navbar. Half the time it renders as a plain flat panel instead — because backdrop-filter blurs whatever is BEHIND an element, and that only shows up if the element itself is see-through. Here's the transparency rule, the stacking-context trap it quietly sets, and why it's one of the priciest effects you can scroll past.
Take the quiz →
Blocking <script> Won't Stop innerHTML XSS. setHTML() Will.
A regex that strips <script> tags misses the XSS that actually runs — an onerror attribute. Element.setHTML(), from the HTML Sanitizer API, strips it natively, and for once Firefox shipped the finished version before Chrome did.
Take the quiz →
Nuxt Server Routes Explained: How Nitro Builds Your API
Nuxt server routes turn server/api into a real backend via Nitro and h3. Learn routing rules, defineEventHandler, middleware order, and the useState trap.
Take the quiz →
Your 'Save' Button Makes Copies. The File System Access API Doesn't.
The classic web 'save' — a Blob and an <a download> link — doesn't overwrite a file, it manufactures a new one every time, leaving notes.md, notes (1).md, notes (2).md scattered in Downloads. The File System Access API fixes this with real, permissioned read-write access to a file on disk. Here's the difference, and why it's Chromium-only progressive enhancement, not a drop-in replacement.
Take the quiz →
Stop Guessing When Scrolling Stops — Use scrollend
For years, 'has the user stopped scrolling?' was a guess: debounce the scroll event, pick a delay, hope. The scrollend event answers the question directly — and as of Safari 26.2, it finally works everywhere. Here's the bug the guess causes, and the one-line fix.
Take the quiz →
Next.js Route Handlers: GET Stopped Caching in 15 — How to Cache in 16
Next.js 15 made GET Route Handlers dynamic by default. What that changes for code written for 14, how to cache one on purpose in 16, plus a cheat sheet.
Take the quiz →
getCurrentPosition() Doesn't Just Check — It Prompts
You want to peek at whether location access is already granted before showing your own 'why we need this' banner. Calling getCurrentPosition() to find out fires the real system prompt. navigator.permissions.query() reads the state without ever asking.
Take the quiz →
NestJS Guards: CanActivate, ExecutionContext & Reflector
A complete guide to NestJS guards: how CanActivate, ExecutionContext, and the Reflector decide who reaches your route handler, with a cheat sheet.
Take the quiz →
localStorage Isn't Free — It's Blocking Your Main Thread
Autosave into localStorage looks harmless right up until the draft gets big. The API is synchronous by spec, so every write freezes the page for exactly as long as it takes — and debouncing doesn't fix it. IndexedDB does.
Take the quiz →
JSON.stringify Is Quietly Deleting Your File Uploads
An avatar upload form that passes every test, ships to production, returns 200 OK — and never actually uploads the picture. The bug is one function call that silently turns a File into an empty object, with no error anywhere.
Take the quiz →
The Background Task That Waited 40 Seconds for 'Idle'
requestIdleCallback promises to run only when the browser has spare cycles — but on a page that's never truly idle, that promise has no upper bound. Here's why the callback can stall, why the timeout escape hatch has its own trap, and when to reach for it instead of setTimeout or scheduler.yield.
Take the quiz →
Vue Composables: The Shared State Trap (+ Cheat Sheet)
Why two Vue components using the same composable can end up sharing state by accident, the mental model that explains it, and how to fix or embrace it.
Take the quiz →
The Dropdown You've Been Faking for a Decade
Every hand-built 'custom select' with icons and a styled popup exists because the real <select> couldn't do that. appearance: base-select just closed the gap — without you losing the native picker's keyboard nav and mobile UI.
Take the quiz →
Next.js proxy.ts Explained (with Cheat Sheet)
Next.js 16 renamed middleware.ts to proxy.ts and locked it to the Node.js runtime. Learn the network-boundary model, matcher config, and the migration path.
Take the quiz →
Stop Writing JavaScript To Fix 100vh On Mobile
Your full-screen hero looks perfect in the simulator and cuts off the CTA on a real phone. It's not a bug in your code — it's `vh` answering a question you didn't ask. Three new units fix it with zero JavaScript.
Take the quiz →
React Derived State: Why That useState Is Probably a Bug
React derived state explained: why syncing a computed value into useState with an Effect causes extra renders and drift, and what to write instead.
Take the quiz →
Your Browser Is Rejecting Every Drop On Purpose
A drop zone with a correctly wired drop listener that never fires — no error, no typo, nothing in the console. The browser is silently refusing the drop by design, and only one specific line stops it.
Take the quiz →
Nuxt Hydration Mismatch: Why It Happens and How to Fix It
A Nuxt hydration mismatch happens when the server's HTML disagrees with the client's first render. Learn why, and the fixes that actually work.
Take the quiz →
Chrome Already Has The Eyedropper You're Building
You're about to build a canvas-based color picker with a magnifier loupe. Chrome shipped a native one years ago — and it can sample pixels your own canvas can't even see.
Take the quiz →
NestJS Testing Module: Provider Overrides (with Cheat Sheet)
A complete guide to NestJS's testing module: how overrideProvider really wires mocks, why get() fails on scoped providers, and using useMocker.
Take the quiz →
The CSS Property That Fixes Dark Mode's Ugly White Boxes
You shipped dark mode. The page is black, the text is white — and then the date picker opens like a floodlight. color-scheme is the one-line CSS property that tells the browser your native form controls need to catch up too.
Take the quiz →
Stop Debouncing Resize. The Browser Already Watches It.
A debounced resize handler comparing window.innerWidth to a magic number can't ever see dark mode or reduced motion — and it fires dozens of times for one thing matchMedia fires once for.
Take the quiz →
Your Fetch Already Streams. You're Buffering It Anyway.
A chat UI that types out its reply letter by letter isn't proof it's streaming — it's often proof the opposite. fetch() delivers a real ReadableStream body, and most code drains it into one string before showing a single character.
Take the quiz →
Next.js Parallel & Intercepting Routes: Modals Done Right
How Next.js parallel routes (@slot) and intercepting routes ((.), (..), (...)) combine to build shareable, refreshable modals — verified against Next.js 16.3.
Take the quiz →
Your Custom Element Is Missing From FormData — ElementInternals Fixes It
A custom <star-rating> element sits inside a <form>, looks like a form field, and gets left out of the submission entirely. The browser has a real fix for this — most teams reach for a hack instead.
Take the quiz →
Vue nextTick Explained: How DOM Updates Are Batched
How Vue batches reactive writes into one DOM update, why the DOM looks stale right after a change, and how nextTick and watch's flush option fix it.
Take the quiz →
The 'Read Aloud' Button That Only Works on the Second Click
A text-to-speech button that works perfectly every time you test it — and silently fails or picks the wrong voice for a real visitor's first click. The bug is a timing race baked into the Web Speech API that most code never accounts for.
Take the quiz →
useAsyncData Keys in Nuxt: Caching, Dedupe & the Sharing Bug
Learn how Nuxt's useAsyncData and useFetch generate cache keys, how dedupe (cancel vs defer) really works, and why wrapper composables silently share data.
Take the quiz →
The Search Highlight That Deletes Your Selection
A search-highlight feature that rebuilds its DOM on every keystroke can wipe out a user's own text selection with no warning. The CSS Custom Highlight API fixes it by styling text ranges without ever touching a DOM node.
Take the quiz →
My .catch() Never Ran. The Bug Was Two Lines Above It
A function that sometimes throws synchronously instead of returning a promise will skip every .catch() chained to it — because the promise never gets created. Promise.try() fixes it, and does one thing try/catch can't.
Take the quiz →
NestJS Module Encapsulation Explained (with Cheat Sheet)
How NestJS module boundaries actually work: what exports really cross, why @Global() isn't a shortcut, and how forwardRef breaks circular module dependencies.
Take the quiz →
NestJS Dependency Injection Explained (with Cheat Sheet)
How the NestJS DI container resolves providers: tokens, module scope, singleton vs request vs transient, and why 'singleton' can still mean two instances.
Take the quiz →
Stop Regex-Parsing document.cookie. Use CookieStore
document.cookie hands you one flat string and no way to know when it changes. The Cookie Store API gives you async get/set/delete and a change event — but its set() defaults to a stricter SameSite than the one you're used to.
Take the quiz →
addDays() Mutated a Date Three Components Away From Where I Called It
A date utility that calls .setDate() and returns the same object looks pure. It isn't — Date is mutable, so the caller and everyone else holding that reference get changed out from under them. Temporal, now shipping in real browsers, fixes it by making dates immutable.
Take the quiz →
React Form Actions: useActionState & useFormStatus Guide
How React 19 form Actions manage pending state automatically — useActionState, useFormStatus, and useOptimistic explained with the bug they replace.
Take the quiz →
I Shipped 'Passwordless Login.' It Still Asked for a Username.
WebAuthn's own demo code creates a credential the browser can't find on its own — so your passkey button quietly turns into a fancier security key instead of an actual passwordless sign-in. One option fixes it.
Take the quiz →
Stop Hardcoding Share Buttons — Use the Web Share API
Every blog footer hardcodes the same row of share icons — X, Facebook, copy link — and none of them know what's actually installed on your phone. The Web Share API hands the job to the OS instead, and it can do something a custom row never could: share an actual file.
Take the quiz →
Next.js Server Actions: Mutations & Security (Cheat Sheet)
Next.js Server Actions look like plain functions but compile to public POST endpoints. Learn the mutation flow, built-in CSRF checks, and the auth you owe.
Take the quiz →
Your Required Field Turns Red Before You Type Anything
A signup form's email input shows a red border the instant the page loads — before the visitor has typed a single character. The obvious CSS causes it, and the obvious fix is a native pseudo-class nobody reaches for first.
Take the quiz →
Web Workers in JavaScript: The Complete Guide
Learn JavaScript Web Workers step by step: message passing, transferable objects, error handling, and a copy-paste cheat sheet for offloading work.
Take the quiz →
One CSS Property Replaces Your Checkbox Hack
Recoloring a checkbox to match the brand usually means appearance: none, a hand-drawn checkmark, and a rebuilt focus ring. accent-color does the same job in one line — and knowing where it stops matters as much as knowing that it works.
Take the quiz →
Screen Wake Lock API: Keep the Screen On Without the Silent-Video Hack
Cooking sites, workout timers, and boarding-pass pages used to autoplay an invisible, muted, looping video for one job only: stopping your phone from locking its screen. The Screen Wake Lock API replaces that hack with three lines of JavaScript — and it comes with one gotcha the docs bury.
Take the quiz →
React Compiler 1.0: What useMemo You Can Delete
React Compiler 1.0 is stable. Here's the re-render model it automates, which useMemo/useCallback/memo calls you can delete, and what still needs you.
Take the quiz →
Your Timer Doesn't Know You Tabbed Away
window blur feels like the obvious way to detect an idle tab, and it's wrong in ways that only show up in production. The Page Visibility API answers the actual question — can anyone see this? — so polling, timers, and video stop wasting work the moment nobody's looking.
Take the quiz →
The await That Silently Breaks navigator.clipboard.writeText()
navigator.clipboard.writeText() only works while the document is focused and the user gesture is still fresh. Any await before the call can let both expire, so a copy button fails with an uncaught NotAllowedError and nobody ever sees why.
Take the quiz →
Shadow DOM Needed JavaScript to Exist. Now It Doesn't.
attachShadow() is a JavaScript-only API with no HTML serialization, so a server-rendered web component ships an empty host element until the client hydrates it. Declarative Shadow DOM attaches the real shadow root during HTML parsing — zero JS required.
Take the quiz →
Next.js Cache Components Explained (with Cheat Sheet)
How Next.js Cache Components decide what's static, what's cached, and what streams — the use cache directive, cacheLife, and Suspense explained.
Take the quiz →
Your SPA Router Reacts to Navigation. The Navigation API Intercepts It.
Double-click a link during a slow route change and most SPA routers render two pages and settle on the wrong one — because they're listening for navigation after it already happened. The Navigation API lets you stop it before it starts.
Take the quiz →
Debounce and Throttle in JavaScript: The Complete Guide
Learn debounce and throttle in JavaScript step by step, with worked examples, edge cases, and a copy-paste cheat sheet for search, scroll, and resize.
Take the quiz →
You Don't Need a WebSocket for That Live Feed
A live notification badge, a progress bar, a dashboard counter — you reached for socket.io and started hand-rolling reconnect logic. The browser already ships a simpler API that does it for you.
Take the quiz →
Nuxt useState vs ref(): Why Server State Leaks Across Users
A module-scope ref() in Nuxt is shared by every request that hits your server. Learn why useState isolates state per user, and how to fix the leak.
Take the quiz →
Delete Your padding-bottom Aspect-Ratio Hack
For a decade the only way to keep a responsive box's shape was a padding percentage and an absolutely positioned wrapper. One CSS property replaces it — with one gotcha on real images nobody warns you about.
Take the quiz →
React Re-render vs Remount: What Actually Triggers Each
A practical guide to React re-render vs remount: what type, position, and key decide, why state resets unexpectedly, and how to force a remount.
Take the quiz →
Stop Using outline: none. Use :focus-visible Instead.
A designer flags the ugly blue focus ring in review. An engineer deletes it with outline: none. Nobody notices the keyboard-only user who now can't tell where they are on the page.
Take the quiz →
NestJS Request Lifecycle Explained (with Cheat Sheet)
A complete guide to the NestJS request lifecycle: the exact order middleware, guards, interceptors, pipes, and filters run, and why it matters.
Take the quiz →
Your Grid Has Invisible Columns: auto-fill vs auto-fit
A responsive card grid that works perfectly with twelve items breaks with two — not from a bug, but from one word in a repeat() you copy-pasted without reading.
Take the quiz →
You're truncating bios with .slice(). Intl.Segmenter knows where the emoji actually end.
A 30-character bio limit that cuts off mid-emoji isn't a rendering bug — it's .length counting UTF-16 code units instead of what's on screen. Intl.Segmenter counts graphemes, words, and sentences the way a reader actually sees them, and every major browser supports it now.
Take the quiz →
Delete Your Auto-Resize Textarea JS. CSS Does It Now.
The scrollHeight hack everyone copy-pastes for auto-growing textareas has a one-line CSS replacement — plus the one gotcha that bites if you skip max-height.
Take the quiz →
JavaScript Closures: The Complete Guide (with Cheat Sheet)
Learn how JavaScript closures really work — lexical scope, private state, memoization, and the classic loop bug — with worked examples and a cheat sheet.
Take the quiz →
CSS Animations Can't Reverse Mid-Flight. The Web Animations API Can.
Toggling a class to restart a CSS animation works — until you need to pause it, reverse it mid-flight, or ask how far through it is. element.animate() returns an object with those methods built in, natively, in every browser you already support.
Take the quiz →
Vue Reactivity Explained: ref vs reactive (+ Cheat Sheet)
A complete guide to Vue reactivity: how ref and reactive really work, why destructuring breaks updates, when to use each, and a copy-paste cheat sheet.
Take the quiz →
JavaScript Proxy and Reflect: The Complete Guide
Learn JavaScript Proxy and Reflect from the ground up — traps, invariants, and reactive state — with worked examples and a copy-paste cheat sheet.
Take the quiz →
The CSS Selector Built to Lose Every Fight
You keep reaching for !important to override a component's styles. There's a selector that fixes this by contributing zero specificity, on purpose.
Take the quiz →
One version bump, 40 files to edit. Import maps fix that.
Bare specifiers like import _ from 'lodash' don't work in a browser without a bundler — unless you tell the browser how to resolve them yourself, in one JSON block instead of forty hardcoded URLs.
Take the quiz →
Your fetch in beforeunload is silently killed. navigator.sendBeacon guarantees delivery.
When the page unloads, the browser may cancel any in-flight fetch or XHR before it completes. navigator.sendBeacon sends a POST the browser commits to delivering, even after the document is gone.
Take the quiz →
The Modal Was Open. So Was Everything Behind It.
A keyboard-only pass found a background button still worked while a modal was open — aria-hidden had hidden it from screen readers but never touched focus or clicks. One boolean attribute, inert, closes that gap in a single line.
Take the quiz →
Stop Writing Regex to Match URLs — The Browser Already Can
A service worker's route regex was missing one anchor and started caching live edit forms as if they were read-only pages. URLPattern, native since 2021, doesn't let you make that mistake.
Take the quiz →
Stop Writing Media Queries for Font Size
A design system audit found five breakpoints for one heading. clamp() replaces all of them with one line that never jumps.
Take the quiz →
I Ripped Out a Carousel Library. CSS Replaced It.
A scroll listener, a debounce, and 200 lines of carousel-library glue code — replaced by three CSS properties that snap smoother than any of it did.
Take the quiz →
Stop Writing Math.cos() in a Resize Listener
CSS learned trigonometry. Here's the radial menu that used to need a resize listener — and doesn't anymore.
Take the quiz →
I Can Finally Delete My max-height: 9999px Animation Hack
CSS transitions have never been able to animate to height: auto, because auto isn't a number the engine can interpolate. calc-size() and interpolate-size finally give it real numbers — no JavaScript, no magic-number ceiling.
Take the quiz →
Five tabs open, one refresh token — the race nobody noticed
Users with multiple tabs open triggered a silent race: every tab refreshed the same expiring auth token at once, and the server started invalidating its own sessions. navigator.locks fixes it with a real mutex, no polling or localStorage hacks required.
Take the quiz →
You copy and reverse the array to find the last match. findLast() searches from the end directly.
The usual workaround — `[...arr].reverse().find()` — allocates a full copy just to walk it backward. ES2023 added `findLast()` and `findLastIndex()` to search from the end without touching the original.
Take the quiz →English B2: mixed conditionals — when the time of the condition and the result differ
The three textbook conditionals assume the if-clause and the result share a time frame. Real regret rarely does. Mixed conditionals are how you say a past mistake still shapes today.
Take the quiz →
Your fetch() in beforeunload is being silently dropped. Use navigator.sendBeacon().
Browsers cancel in-flight network requests when a page unloads. The common fix — synchronous XHR — is deprecated. `navigator.sendBeacon()` is the correct, fire-and-forget API designed exactly for this case.
Take the quiz →Spanish A2: pretérito vs imperfecto — the photo and the film
Spanish has two past tenses and they are not interchangeable. One takes a photograph of a completed event; the other films the background it happened against.
Take the quiz →