# Certificates.dev

> Official certification exams for Vue.js, Nuxt, Angular, JavaScript, TypeScript, React and Laravel — validate your skills with industry-recognized credentials.

## Certifications

Technology-specific certification landing pages

- [Vue.js Certification](https://certificates.dev/vuejs): Official Vue.js certification by the Vue team
- [Nuxt Certification](https://certificates.dev/nuxt): Official Nuxt certification
- [Angular Certification](https://certificates.dev/angular)
- [JavaScript Certification](https://certificates.dev/javascript)
- [TypeScript Certification](https://certificates.dev/typescript)
- [React Certification](https://certificates.dev/react)
- [Laravel Certification](https://certificates.dev/laravel)
- [Artisan Certification](https://certificates.dev/artisan)

## For Teams & Companies

- [For Teams](https://certificates.dev/for-teams)
- [Team Certification](https://certificates.dev/team-certification)
- [Company Certification](https://certificates.dev/company-certification)
- [Partnerships](https://certificates.dev/partnerships)

## Resources

- [Blog](https://certificates.dev/blog)
- [Cheat Sheets](https://certificates.dev/cheat-sheets)
- [Press Release](https://certificates.dev/press-release)
- [Type-Safe Server Routes](https://certificates.dev/blog/type-safe-server-routes): Type-Safe Server Routes: End-to-End Types from server/api to Your Components How Nuxt infers response types from your server routes so useFetch and $fetch calls are fully typed without manual interfaces.
- [How to create nested routes with Angular?](https://certificates.dev/blog/how-to-create-nested-routes-with-angular-1): Learn how Angular nested routes and child routes work with multiple router outlets, and see how to use them to build navigable sections such as tabbed dashboards.
- [Structuring a Large Vue App: A Feature-Based Folder Architecture](https://certificates.dev/blog/structuring-a-large-vue-app-a-feature-based-folder-architecture): Why the default components/composables/stores split breaks down at scale, and how a feature-first structure fixes it.
- [Proxy and Reflect: Metaprogramming in JavaScript](https://certificates.dev/blog/proxy-and-reflect-metaprogramming-in-javascript): Learn how JavaScript Proxy and Reflect intercept object operations: the 13 traps and why Reflect matters.
- [React's New browser API: Rendering Components Only in the Browser](https://certificates.dev/blog/reacts-new-browser-api-rendering-components-only-in-the-browser): Learn how React’s new Canary browser API uses Suspense to render browser-only components without hydration mismatches or mounted-state workarounds.
- [Building an MCP Server in Your Nuxt App](https://certificates.dev/blog/building-an-mcp-server-in-your-nuxt-app): Building an MCP Server in Your Nuxt App with the MCP Toolkit. How to expose your Nuxt app's data and actions to AI assistants using @nuxtjs/mcp-toolkit, with tools, resources, and prompts.
- [Tighter TypeScript in <script setup>](https://certificates.dev/blog/tighter-typescript-in-script-setup): How Vue sharpened TypeScript support for defineProps, defineEmits, defineModel, and defineSlots, and how to write clearer component contracts.
- [Intl.NumberFormat and Intl.RelativeTimeFormat: The Traps](https://certificates.dev/blog/intlnumberformat-and-intlrelativetimeformat-the-traps): Intl.NumberFormat and Intl.RelativeTimeFormat replace your formatting library. Defaults, traps, and the 58x performance mistake to avoid.
- [Component Architecture for React Server Components](https://certificates.dev/blog/component-architecture-for-react-server-components): React Server Components let each component fetch its own data, so pages compose instead of prop-drilling. How that reshapes architecture, loading boundaries, and UX.
- [Background Jobs with Nitro Tasks API](https://certificates.dev/blog/background-jobs-with-nitro-tasks-api): How to run one-off and scheduled background work in Nuxt using Nitro's Tasks API, and what to watch for per deployment platform.
- [What’s new in Angular 22.1?](https://certificates.dev/blog/whats-new-in-angular-221): Angular 22.1 introduces a major change to Angular’s release cycle, moving to one major release per year. Learn what this means for Angular upgrades, versioning, and the future of the framework.
- [Nuxt 3 hits End Of Life](https://certificates.dev/blog/nuxt-3-hits-end-of-life): Nuxt 3 Hits EOL July 31, 2026: Your Staged Path to Nuxt 5 What the Nuxt 3 end-of-life date means, how to migrate through Nuxt 4, and when it makes sense to wait for Nuxt 5 instead.
- [How YouTube Works, and Why It Plays in One Second](https://certificates.dev/blog/how-youtube-works): How does YouTube start almost any video in about a second? Here's the architectural bet behind it, and why the real call still belongs to you.
- [Building a Vue Career in the Age of AI Coding Tools](https://certificates.dev/blog/building-a-vue-career-in-the-age-of-ai-coding-tools): How Junior Vue Developers Can Get Hired in 2026 and and what companies are looking for
- [The flat() and flatMap() methods](https://certificates.dev/blog/the-flat-and-flatmap-methods): Learn how JavaScript's flat() and flatMap() work: default depth, flat(Infinity), dropping holes, and using flatMap as a combined map and filter.
- [Vapor Mode in Practice](https://certificates.dev/blog/vapor-mode-in-practice): A hands-on look at opting individual components into Vue 3.6 Vapor Mode, where it helps, and the real limitations as of mid-2026.
- [The First Hands-On AI Developer Certification](https://certificates.dev/blog/the-first-hands-on-ai-developer-certification): Discover how the AI Developer Certification measures real-world AI-assisted development through a hands-on, proctored exam. Learn what makes the certification unique, how it works, and what to expect when preorders open.
- [Nuxt Studio and What It Is](https://certificates.dev/blog/nuxt-studio-and-what-it-is): A look at Nuxt Studio, the open-source visual CMS for Nuxt Content, how it works with Git, and when it's the right fit.
- [JavaScript Generators: Writing Iterators With yield](https://certificates.dev/blog/javascript-generators-writing-iterators-with-yield): JavaScript generators explained: write lazy iterators with yield, handle infinite sequences, and skip the protocol boilerplate.
- [Designing Loading UI in React](https://certificates.dev/blog/designing-loading-ui-in-react): A practical guide to loading UI in React: Suspense boundaries, skeletons vs spinners, avoiding layout shift, and animating reveals.
- [Performance Optimization in Nuxt](https://certificates.dev/blog/performance-optimization-in-nuxt-1): Practical techniques for faster Nuxt apps
- [How to Add Async HTTP Validators to Angular Signal Forms](https://certificates.dev/blog/how-to-add-async-http-validators-to-angular-signal-forms): Learn how to implement asynchronous validation in Angular Signal Forms using validateHttp(). This guide shows how to validate user input with APIs for uniqueness checks, server-side rules, and other HTTP-based validation scenarios.
- [Cache Components in Next.js](https://certificates.dev/blog/cache-components-in-nextjs): Cache Components is the Next.js 16 caching model behind Instant Navigations. Learn use cache, cacheLife, and cacheTag, and why data is dynamic by default.
- [Migrating to Vite 8 + Rolldown](https://certificates.dev/blog/migrating-to-vite-8-rolldown): A step-by-step account of upgrading a production Vue app to Vite 8 and Rolldown, the config changes that broke, and the actual build numbers before and after.
- [JavaScript Set Methods: Native Set Theory, Finally](https://certificates.dev/blog/javascript-set-methods-native-set-theory-finally): Seven new methods landed on JavaScript's Set: union, intersection, difference, and more. Baseline since 2024. A practical guide with real-world examples.
- [How to Debounce Angular Signals?](https://certificates.dev/blog/how-to-debounce-angular-signals): Learn how to debounce Angular 22 Signal Forms to improve performance and reduce unnecessary HTTP requests. This guide explains when debouncing is useful and how to implement it for smoother, more efficient user interactions.
- [How the Queue Worker Loop Actually Works](https://certificates.dev/blog/how-the-queue-worker-loop-actually-works): Master Laravel queues by understanding what happens behind the scenes when jobs are dispatched and processed. This guide explores queue workers, model serialization, retries, failed jobs, chaining, and batching—key concepts for building reliable applications and succeeding in Laravel certification exams.
- [Getting Started with rstore in Vue](https://certificates.dev/blog/getting-started-with-rstore-in-vue): A walkthrough of rstore, the reactive data store for Vue with normalized caching, typed queries, and a plugin system.
- [Promise.withResolvers(): The Deferred Pattern Built-In](https://certificates.dev/blog/promisewithresolvers-the-deferred-pattern-built-in): Promise.withResolvers() replaces the manual deferred pattern in JavaScript. One destructuring, no executor, no let. ES2024, supported in all modern runtimes.
- [Error Handling in Next.js with catchError](https://certificates.dev/blog/error-handling-in-nextjs-with-catcherror): Learn why react-error-boundary falls short in the Next.js App Router and how catchError from Next.js 16.2 fixes both framework error propagation and server data refetching with a single function call.
- [SEO in Nuxt with @nuxtjs/seo](https://certificates.dev/blog/seo-in-nuxt-with-at-nuxtjsseo): Set up sitemaps, meta tags, structured data, OG images, and robots.txt in Nuxt with the official SEO module.
- [What’s the untracked function? [Angular Signals]](https://certificates.dev/blog/whats-the-untracked-function-angular-signals): Learn how Angular's computed() function derives reactive values from signals and why it plays a key role in building high-performance, signal-based applications with cleaner and more predictable state management.
- [Events and Listeners: The Event System From the Inside Out](https://certificates.dev/blog/events-and-listeners-the-event-system-from-the-inside-out): Laravel events are more than a way to decouple application logic. This article explores how the event system works under the hood, from dispatching and listeners to the internals that frequently appear on Laravel certification exams, helping you build a deeper understanding beyond basic usage.
- [Building 3D Scenes with TresJS](https://certificates.dev/blog/building-3d-scenes-with-tresjs): A hands-on walkthrough of TresJS, the Vue custom renderer for Three.js. From a blank canvas to a reactive 3D scene.
- [`using` in JavaScript: Automatic Resource Management](https://certificates.dev/blog/using-in-javascript-automatic-resource-management): Learn how the new using keyword and Symbol.dispose replace try/finally for cleaner resource management in JavaScript. With ES2026 support details.
- [State Management in React: useReducer, Context, and External Stores](https://certificates.dev/blog/state-management-in-react-usereducer-context-and-external-stores): Learn when to move beyond useState in React. This guide covers useReducer, the split-context pattern, external stores like Zustand, server state with TanStack Query, and useSyncExternalStore.
- [Deploying Nuxt: Presets, Platforms, and Hybrid Rendering](https://certificates.dev/blog/deploying-nuxt-presets-platforms-and-hybrid-rendering): How to deploy Nuxt to Vercel, Netlify, Cloudflare, and Node, with hybrid rendering via routeRules.
- [Trigger options for @defer](https://certificates.dev/blog/trigger-options-for-at-defer): Learn how Angular's @defer block triggers lazy loading and explore the different loading strategies available to control when components are rendered for better performance and user experience.
- [Middleware: What It Is, How It Chains, and When to Write Your Own](https://certificates.dev/blog/middleware-what-it-is-how-it-chains-and-when-to-write-your-own): Middleware is one of Laravel’s most tested certification topics because it sits at the core of the request lifecycle. This article goes beyond basic syntax to explain how middleware works internally, how the pipeline pattern processes requests, what happens when $next is skipped, and why some middleware never executes. If you want to truly understand Laravel middleware rather than just use it, this is where to start.
- [Rolldown and Vite 8: What Changed](https://certificates.dev/blog/rolldown-and-vite-8-what-changed): Vite 8 replaced both esbuild and Rollup with Rolldown. Here's what that means for your Vue project in practice.
- [Closures Explained: How Functions Remember Their Scope](https://certificates.dev/blog/closures-explained-how-functions-remember-their-scope): A function in JavaScript remembers the scope it was created in, even after that scope has finished executing. Learn what closures are, why the loop bug happens, and how to use them in practice.
- [Writing Custom Hooks in React: Patterns, Pitfalls, and When to Reach for One](https://certificates.dev/blog/writing-custom-hooks-in-react-patterns-pitfalls-and-when-to-reach-for-one): A practical guide to writing custom React Hooks: the patterns they replaced, the rules they must follow, when to extract one, and libraries that cover the rest.
- [State Management in Nuxt: Pinia or sticking to basics?](https://certificates.dev/blog/state-management-in-nuxt-pinia-or-sticking-to-basics): Using Pinia vs Basic State Management: When Vue's built-in reactivity is enough and when Pinia earns its place in your project.
- [Modern Angular: Replacing Lifecycle Hooks with Signals](https://certificates.dev/blog/modern-angular-replacing-lifecycle-hooks-with-signals): As an Angular developer, you’ve likely used lifecycle hooks such as ngOnChanges, ngOnInit, and ngOnDestroy. With the advent of Zoneless and Signals, we can use better, more readable options.
- [How Eloquent Actually Builds Your Models](https://certificates.dev/blog/how-eloquent-actually-builds-your-models): A deep dive into Laravel Eloquent under the hood — explore how models are resolved, hydrated, and persisted, and uncover the internal mechanics most developers use daily but rarely fully understand.
- [The Role Vite Plays in Vue](https://certificates.dev/blog/the-role-vite-plays-in-vue): What Vite actually does in a Vue project, from dev server to production build, and why it replaced Vue CLI.
- [JavaScript finally gets dates right](https://certificates.dev/blog/javascript-finally-gets-dates-right): JavaScript's Date object is 30 years old, copied from Java, and never really fixed. Temporal is the native API that finally gets dates right: immutable, timezone-aware, and no more dividing by 86400000.
- [Security in React Applications](https://certificates.dev/blog/security-in-react-applications): Learn how to secure React apps: prevent XSS with DOMPurify, store tokens safely in HttpOnly cookies, validate server inputs with Zod, and configure Content Security Policy.
- [Is Nuxt something for “me”?](https://certificates.dev/blog/is-nuxt-something-for-me): Using Nuxt vs Not Using Nuxt: A side-by-side comparison of building the same features in plain Vue and Nuxt, so you can see exactly what the framework gives you.
- [RxJS to Angular Signals: Patterns, Pitfalls, and Practical Tips](https://certificates.dev/blog/rxjs-to-angular-signals-patterns-pitfalls-and-practical-tips): Migrating from RxJS to Signals in Angular? This guide breaks down common patterns, practical tips, and step-by-step strategies to help you transition smoothly from reactive streams to a signals-based architecture.
- [The Laravel Request Lifecycle, Step by Step](https://certificates.dev/blog/the-laravel-request-lifecycle-step-by-step): Follow a Laravel HTTP request from start to finish, exploring when the container is built, service providers run, and controllers execute—demystifying the framework step by step.
- [Plain Vue or going Meta?](https://certificates.dev/blog/plain-vue-or-going-meta): Using Vue plainly or adding Nuxt to it:  side-by-side comparison of building the same features in plain Vue and Nuxt, so you can see exactly what the framework gives you.
- [Nullish Coalescing Operator](https://certificates.dev/blog/nullish-coalescing-operator): Understand the difference between || and ?? in JavaScript, and learn how the nullish coalescing operator avoids common pitfalls with falsy values like 0, empty strings, and false.
- [Accessibility in React: Common Mistakes and How to Fix Them](https://certificates.dev/blog/accessibility-in-react-common-mistakes-and-how-to-fix-them): A look at the most common accessibility mistakes in React applications: missing semantics, broken focus management, unlabeled elements, and silent dynamic updates. Covers what to fix, when to use component libraries, and how to audit your app.
- [Composable Best Practices in Nuxt](https://certificates.dev/blog/composable-best-practices-in-nuxt): Learn how to use composables in Nuxt effectively, avoid common SSR and state pitfalls, and build production-ready patterns in this practical 15-minute guide.
- [How to create nested routes with Angular?](https://certificates.dev/blog/how-to-create-nested-routes-with-angular): Learn how nested (child) routes work in Angular, why multiple router outlets are useful, and how to implement tabbed navigation in complex dashboards.
- [How the Laravel Service Container Actually Works Under the Hood](https://certificates.dev/blog/how-the-laravel-service-container-actually-works-under-the-hood): Go beyond the “magic” of Laravel’s dependency injection. Learn how the service container works under the hood and why it’s essential for building clean, testable, and maintainable applications.
- [JavaScript Mistakes That Quietly Destroy Production Apps](https://certificates.dev/blog/javascript-mistakes-that-quietly-destroy-production-apps): Some JavaScript mistakes don’t crash your app, they slowly degrade performance, reliability, and user trust. Here are the ones that cost the most in production.
- [TanStack Start and Router: What You Need to Know](https://certificates.dev/blog/tanstack-start-and-router-what-you-need-to-know): An overview of TanStack Start and TanStack Router — type-safe routing, validated search params, server functions, middleware, SSR, and how to get started.
- [Handling Content in Nuxt](https://certificates.dev/blog/handling-content-in-nuxt): A practical walkthrough of @nuxt/content for querying, rendering, and navigating markdown-based content in Nuxt.
- [How to Pick the Right Dependencies for Your Angular Application](https://certificates.dev/blog/how-to-pick-the-right-dependencies-for-your-angular-application): Choosing the right libraries/dependencies for your Angular applications can make or break your project in the long run. Learn how to pick the right dependencies.
- [Accessible Vue Apps](https://certificates.dev/blog/accessible-vue-apps): Build more accessible Vue apps with practical guidance on semantic HTML, ARIA bindings, focus management, accessible routing, keyboard navigation, and common mistakes to avoid.
- [Building a Full-Stack app with Nuxt and the Supabase MCP](https://certificates.dev/blog/building-a-full-stack-app-with-nuxt-and-the-supabase-mcp): Advanced Agentic AI & Nuxt: MCP setup, schema design, policies, server routes and the full-stack agentic workflow recap with code examples
- [AI Coding in React: What You Still Need to Know](https://certificates.dev/blog/ai-coding-in-react-what-you-still-need-to-know): AI tools like Cursor and Copilot make React development faster, but your React knowledge determines how good the output is. Here's what you need to know.
- [Reactivity Best Practices in Vue](https://certificates.dev/blog/reactivity-best-practices-in-vue): Learn Vue 3 reactivity best practices, including ref vs reactive, computed caching, watch vs watchEffect, common pitfalls, and performance tips.
- [Custom Errors in JavaScript: Extending Error the Right Way](https://certificates.dev/blog/custom-errors-in-javascript-extending-error-the-right-way): Learn how to extend JavaScript’s Error class correctly, build error hierarchies, and wrap exceptions for clean, scalable error handling.
- [Lazy-loading with @defer](https://certificates.dev/blog/lazy-loading-with-at-defer): Master Angular lazy-loading with @defer and learn how to control triggers, placeholders, loading behaviour, and error states for standalone components.
- [React Server Components in Practice: Patterns and Pitfalls](https://certificates.dev/blog/react-server-components-in-practice-patterns-and-pitfalls): Practical patterns for React Server Components: where to place the server/client boundary, composing Server and Client Components, avoiding data fetching waterfalls, streaming with Suspense, serialization rules, and common pitfalls.
- [Building a Blog app with Nuxt Content and Agentic AI](https://certificates.dev/blog/building-a-blog-app-with-nuxt-content-and-agentic-ai): Nuxt and Agentic AI: MCPs explained, setting up a Nuxt project with Claude Code, guiding the agent with good prompts (bad vs good prompt examples), MCP context-awareness, finishing and polishing
- [What Does Zoneless Angular Mean?](https://certificates.dev/blog/what-does-zoneless-angular-mean): Explore what “zoneless” Angular means—how change detection works without Zone.js, what triggers updates instead, and the best practices (Signals, OnPush, async pipe) to get ready.
- [JavaScript Modules Explained: The Foundation of Modern JS Applications](https://certificates.dev/blog/javascript-modules-explained-the-foundation-of-modern-js-applications): A deep, practical explanation of JavaScript ES Modules: execution model, shared exports, strict mode, browser rules, and real-world implications.
- [Server-side rendering: SSR or SSG, what’s the difference?](https://certificates.dev/blog/server-side-rendering-ssr-or-ssg-whats-the-difference): This is a clear breakdown of SSR (Server-Side Rendering) vs SSG (Static Site Generation) in Angular—explaining how they work, key differences like runtime vs build-time rendering, hydration behavior, server requirements, and how to choose the right strategy per route.
- [React Docs Refresh: useActionState and useOptimistic](https://certificates.dev/blog/react-docs-refresh-useactionstate-and-useoptimistic-if-you-tried-learning-useactionstate-or-useoptimistic-from-the-original-react-19-docs-and-came-away-confused-now-is-a-great-time-to-go-back-both-pages-have-been-completely-reworked-with-ne): The React docs for useActionState and useOptimistic have been rewritten with clearer naming, new interactive sandboxes, and patterns from simple pending states to shopping carts with error recovery. Here's what changed and why it matters.
- [Build Stronger Engineering Standards For Your Team](https://certificates.dev/blog/build-stronger-engineering-standards-for-your-team): Standardise engineering standards in an AI-accelerated environment. Certificates.dev for Teams adds a Team Dashboard, reporting, and procurement-friendly purchasing.
- [Supercharging Nuxt Apps with VueUse](https://certificates.dev/blog/supercharging-nuxt-apps-with-vueuse): Nuxt encourages composables and VueUse gives you really good ones. If you’re building Nuxt apps and not using VueUse yet, you’re probably working harder than you need to.
- [Breaking Down State of React 2025 Results](https://certificates.dev/blog/breaking-down-state-of-react-2025-results): The State of React 2025 survey results are out. Explore what developers said about hooks, APIs, frameworks, React Server Components, and the tools shaping the React ecosystem today.
- [Angular Signal Forms — Set-up and validation rules](https://certificates.dev/blog/angular-signal-forms-set-up-and-validation-rules): The article explains Angular’s experimental Signal Forms (introduced with Angular 21), showing how they provide a third approach to building forms alongside template-driven and reactive forms by using signals to manage form data, state, and validation more directly and intuitively, including centralized, reusable validation rules and simpler access to field status like validity, errors, and user interaction.
- [Vanilla JavaScript in 2026: Why You Still Can’t Ignore It](https://certificates.dev/blog/vanilla-javascript-in-2026-why-you-still-cant-ignore-it): Vanilla JavaScript in 2026: Why You Still Can’t Ignore It
- [What's New in React 19.2](https://certificates.dev/blog/whats-new-in-react-192): Learn what's new in React 19.2: Activity for state-preserving UI, useEffectEvent for cleaner effects, compiler-powered ESLint rules, and Performance Tracks in DevTools.
- [What’s new in Angular 21.1?](https://certificates.dev/blog/whats-new-in-angular-211): Angular 21.1 is out, and while most of the new features are still experimental, the release gives us a solid preview of where Angular is heading. From Signal Forms API changes and long-awaited focus helpers, to more flexible control flow, template improvements, router updates, and MCP server enhancements, this version is packed with ideas worth exploring—just not shipping to production yet. Let’s take a quick look at what’s new and what’s promising.
- [How to pass your certification exam](https://certificates.dev/blog/how-to-pass-your-certification-exam): Getting ready for the Nuxt certification exam? See how the exam works, what’s on it, and how to prep so you can actually pass it on the first try.
- [The JavaScript Event Loop: The Skill That Separates Juniors From Seniors](https://certificates.dev/blog/the-javascript-event-loop-the-skill-that-separates-juniors-from-seniors): Promises, async/await, timers…everything in JavaScript relies on the event loop. Mastering it changes how you write and debug code.
- [Anti-pattern series: Not unsubscribing from Observables](https://certificates.dev/blog/anti-pattern-series-not-unsubscribing-from-observables): This article explains how Angular 16 improves observable cleanup using takeUntilDestroyed and recommends applying it in services rather than components, so all subscribers are automatically protected from memory leaks.
- [React Compiler: No More useMemo and useCallback](https://certificates.dev/blog/react-compiler-no-more-usememo-and-usecallback): React Compiler automatically optimizes your components at build time. No more useMemo, useCallback, or React.memo. Learn how to set it up and what you need to know.
- [Building Better Abstractions with Vue Render Functions](https://certificates.dev/blog/building-better-abstractions-with-vue-render-functions): Learn a practical pattern for using Vue render functions to build better abstractions and simplify your component architecture
- [JavaScript Isn’t Slow. You’re Just Using It Wrong.](https://certificates.dev/blog/javascript-isnt-slow-youre-just-using-it-wrong): JavaScript is not inherently slow. Poor architectural choices are. Here’s how modern JavaScript actually performs, and where developers really lose speed.
- [How to animate transitions with Angular?](https://certificates.dev/blog/how-to-animate-transitions-with-angular): Angular 20.2 introduces a delightfully simple way to animate elements as they enter and leave the screen. With zero imports and CSS doing all the heavy lifting, the new animate.enter and animate.leave attributes let you add smooth, modern transitions with minimal code and maximum sanity.
- [Starting a React Project? shadcn/ui, Radix, and Base UI Explained](https://certificates.dev/blog/starting-a-react-project-shadcnui-radix-and-base-ui-explained): Understand unstyled component libraries, compare Radix and Base UI, and learn how shadcn/ui and shadcn/create help you build React apps your way.
- [Understanding try...catch in JavaScript: How to Handle Errors Properly](https://certificates.dev/blog/understanding-trycatch-in-javascript-how-to-handle-errors-properly): Learn how JavaScript errors work and how to prevent your app from crashing using try...catch. Includes simple examples, async caveats, custom errors, JSON parsing, and best practices for writing robust, user-friendly code.
- [Dynamic component creation with Angular](https://certificates.dev/blog/dynamic-component-creation-with-angular): The article explains how to create and control Angular components dynamically at runtime, rather than relying on static components that are toggled visible/hidden in the DOM.
- [The Curious Case of Vue’s Function Props](https://certificates.dev/blog/the-curious-case-of-vues-function-props): A curious look at Vue’s function props and their unexpected advantages over emits.
- [Nuxt UI: Unapologetically complete](https://certificates.dev/blog/nuxt-ui-unapologetically-complete): Nuxt UI: The Shortcut You Don’t Have to Apologize For  The component library that was built with developer experience in mind and solves accessibility and dependency management problems.
- [Controlled vs Uncontrolled Components in React](https://certificates.dev/blog/controlled-vs-uncontrolled-components-in-react): Understanding controlled vs uncontrolled in React is about one question: who owns the state? Learn both meanings for form inputs and component design patterns.
- [The 8 JavaScript Errors Every Developer Should Understand](https://certificates.dev/blog/the-8-javascript-errors-every-developer-should-understand): Understanding JavaScript errors is essential for debugging efficiently. Discover the 8 native error types with clear explanations and practical examples.
- [Nuxt Hints: A new core module dropped right before the end of the year 🎁](https://certificates.dev/blog/nuxt-hints-a-new-core-module-dropped-right-before-the-end-of-the-year): The newest and hottest Nuxt module that was released right before the end of 2025: Nuxt Hints It gives real-time feedback on your app’s performance, accessibility, and security.
- [Angular 21 is available!](https://certificates.dev/blog/angular-21-is-available): Angular 21 has been released, and I’m going to divide the new features into different categories, since a lot of the new features are experimental and not recommended for production use yet.
- [Special Nuxt Features on an opt-in basis](https://certificates.dev/blog/special-nuxt-features-on-an-opt-in-basis): Extra Nuxt config options that go further and could help unlock new possibilities.
- [Inside the JavaScript Event Loop: How the Runtime Actually Works](https://certificates.dev/blog/inside-the-javascript-event-loop-how-the-runtime-actually-works): Understand the JavaScript event loop in depth. Learn how the call stack, microtasks, and macrotasks work together to handle asynchronous code efficiently, keeping your applications fast, predictable, and responsive.
- [React Free Weekend: 48 hours of Open Access to Premium React Certification Training](https://certificates.dev/blog/react-free-weekend-48-hours-of-open-access-to-premium-react-certification-training): Every year, we at Certificates.dev look for ways to make our certifications more accessible - not just for teams inside big tech companies, but for every developer who wants to validate their skills through real-world, hands-on learning.  That’s why we are excited to announce our first-ever React Free Weekend, taking place on November 15–16, 2025.
- [Error Handling in React with react-error-boundary](https://certificates.dev/blog/error-handling-in-react-with-react-error-boundary): Learn how to handle errors in React applications with react-error-boundary. Explore fallback UIs, async error handling with useErrorBoundary, and React 19's automatic error boundary integration with form actions and useTransition.
- [Document Fragments: The Secret to Fast, Clean DOM Manipulation in JavaScript](https://certificates.dev/blog/document-fragments-the-secret-to-fast-clean-dom-manipulation-in-javascript): Discover how DocumentFragment can dramatically speed up DOM manipulation in JavaScript. Learn how to batch element creation in memory, avoid reflows, and build smoother, faster interfaces with clean, efficient code.
- [Wait for that tick](https://certificates.dev/blog/wait-for-that-tick): Learn how Vue's nextTick works, why DOM updates are batched, and how to avoid timing issues when working with refs and animations.
- [Exploring Server Components in Nuxt](https://certificates.dev/blog/exploring-server-components-in-nuxt): Nuxt offers experimental features like Server Components to take make performant applications. Let’s take a look back at how hydration works and how Nuxt handles Server Side Rendering.
- [Building Reusable Components with React 19 Actions](https://certificates.dev/blog/building-reusable-components-with-react-19-actions): Build reusable React components with React 19 Actions using useTransition() and useOptimistic(). Learn how to track pending states, implement optimistic updates, and expose action properties for custom logic in the Next.js App Router with practical examples.
- [Falling with Style](https://certificates.dev/blog/falling-with-style): Learn how Vue.js fall-through attributes work, when they're useful, and common pitfalls to avoid. Master class, style, and event handling in components.
- [Use Lighthouse to improve your Angular applications](https://certificates.dev/blog/use-lighthouse-to-improve-your-angular-applications): Angular developers often focus on code structure and framework mastery—but end users care most about speed, accessibility, and visibility. This article highlights how tools like Google Chrome’s built-in Lighthouse can help you measure and improve your app’s performance, accessibility, and SEO. By running quick audits and reviewing actionable insights, developers can bridge the gap between technical excellence and real-world user experience.
- [Template Literals in JavaScript: Write Strings the Way They Were Meant to Be](https://certificates.dev/blog/template-literals-in-javascript-write-strings-the-way-they-were-meant-to-be): Learn how template literals make JavaScript string handling modern, readable, and expressive through multi-line syntax, interpolation, and tag functions. A concise expert guide for cleaner, smarter code.
- [Dynamic Imports in JavaScript: Load Smarter, Not Sooner](https://certificates.dev/blog/dynamic-imports-in-javascript-load-smarter-not-sooner): Learn how to use dynamic imports in JavaScript to boost performance, reduce bundle size, and load code only when needed. A practical, modern guide to smarter, modular JavaScript without frameworks.
- [Building an Async Combobox with useSuspenseQuery() and useDeferredValue()](https://certificates.dev/blog/building-an-async-combobox-with-usesuspensequery-and-usedeferredvalue): Learn how to build a responsive async combobox component using React's useDeferredValue() and useSuspenseQuery(). Discover how these concurrent features work together to create smooth user experiences with declarative loading states, optimistic updates, and automatic caching for search interfaces.
- [Subject, BehaviorSubject, and ReplaySubject](https://certificates.dev/blog/subject-behaviorsubject-and-replaysubject): Angular’s reactive world revolves around Subjects, but the star is often the BehaviorSubject — why? Because it always starts with a value, and when you subscribe, you immediately get the latest emission (like receiving the current issue of a magazine). Meanwhile, ReplaySubject lets you go further by replaying multiple past values (no default), and a plain Subject is just “live only” — no past, no future. Let’s dig into when and why to use each.
- [Unravel the mystery of JavaScript's event bubbling and take control of your event handling](https://certificates.dev/blog/unravel-the-mystery-of-javascripts-event-bubbling-and-take-control-of-your-event-handling-1): Ever clicked a button and had unexpected things happen to its parent elements? You might have just witnessed the magic (or mischief!) of JavaScript's event bubbling. It's a core concept that, once understood, will save you headaches and help you debug event-related issues.
- [Serverless functions in Nuxt: backend power without a backend](https://certificates.dev/blog/serverless-functions-in-nuxt-backend-power-without-a-backend): Serverless functions are tiny pieces of code that run on demand in the cloud. You don’t provision servers or infrastructure, or write scaling rules. Cloud providers handle the underlying infrastructure, automatically scaling resources based on demand.  They’re perfect for lightweight APIs, form handlers, webhooks, simple auth endpoints, and glue code.
- [React Frameworks and Server-Side Features: Beyond Client-Side Rendering](https://certificates.dev/blog/react-frameworks-and-server-side-features-beyond-client-side-rendering): Learn React's server-side features: SSR with streaming, static pre-rendering, hydration, Server Components, and Server Functions. Discover how frameworks like Next.js enable modern full-stack React development.
- [Promises in JavaScript: Receipts for Future Values and Advanced Patterns](https://certificates.dev/blog/promises-in-javascript-receipts-for-future-values-and-advanced-patterns): JavaScript Promises manage future values with clean async handling. Learn how Promise.all, race, allSettled, and any simplify parallel tasks, timeouts, and error management.
- [Vue's Magical Reactivity Has Some Quirks](https://certificates.dev/blog/vues-magical-reactivity-has-some-quirks): Why does Vue's reactivity sometimes behave unexpectedly? Explore ref unwrapping edge cases and cloning complications with clear examples and fixes.
- [Signals + HTTP = httpResource [Tutorial]](https://certificates.dev/blog/signals-http-httpresource-tutorial): Angular 19.2 rolls out httpResource — an experimental, signal-friendly layer over HttpClient that lets you fetch data reactively. Instead of juggling Observables and state flags, httpResource gives you built-in signals like isLoading() and hasValue(), and it automatically re-fires requests when dependent signals (e.g. page number, query) change.
- [Data Fetching Game in Nuxt: Advanced Level](https://certificates.dev/blog/data-fetching-game-in-nuxt-advanced-level): This article shows how Nuxt uses enhanced control in useFetch / useAsyncData: with dedupe: 'defer' to skip duplicate fetches, retry & retryDelay to handle flaky endpoints, and delay to smooth UI transitions. These options yield cleaner, faster, and more resilient data flows—especially helpful for reactive interfaces and unstable networks.
- [React <ViewTransition>: Smooth Animations Made Simple](https://certificates.dev/blog/react-viewtransition-smooth-animations-made-simple): Discover React’s new ViewTransition component and how it leverages concurrent features to create smooth, browser-native animations. Learn enter/exit effects, shared element transitions, list filtering, and Suspense integration with practical examples and CSS customization tips.
- [The Angular Compiler: From Your Code to Browser Code](https://certificates.dev/blog/the-angular-compiler-from-your-code-to-browser-code): This article demystifies what Angular actually bundles into your browser—including how your component and template code gets compiled into a hashed, minified main-xxxxx.js file for cache-busting—and shows how disabling optimization in angular.json lets you peek at the more human-readable compiled output.
- [Just Use useTemplateRef for Template Refs](https://certificates.dev/blog/just-use-usetemplateref-for-template-refs): Vue 3.5's useTemplateRef eliminates template ref headaches: no more type mismatches, silent typos, or verbose component typing. Here's why it's worth the switch.
- [Closures: private state, tiny surface](https://certificates.dev/blog/closures-private-state-tiny-surface): JavaScript closures give functions memory: private state without globals, safer APIs, and predictable behavior. See what they are, when to use them, and why.
- [Component architecture with inputs, model(), and viewChild()](https://certificates.dev/blog/component-architecture-with-inputs-model-and-viewchild): This article explores three distinct approaches to facilitating communication between a parent component and a dialog component in Angular, using a single interactive example centered on opening and closing a dialog.
- [React Concurrent Features: An Overview](https://certificates.dev/blog/react-concurrent-features-an-overview): Learn React's key concurrent features—useTransition, useDeferredValue, Suspense, and useOptimistic—and how they coordinate to create smooth, responsive user experiences. Includes practical examples and best practices.
- [React Children and cloneElement: Component Patterns from the Docs](https://certificates.dev/blog/react-children-and-cloneelement-component-patterns-from-the-docs): Explore React's Children utilities and cloneElement API through their excellent documentation. Learn about compound component patterns, understand their limitations, and discover why modern alternatives like render props and context are often better choices for component composition.
- [Structuring State in React: 5 Essential Patterns](https://certificates.dev/blog/structuring-state-in-react-5-essential-patterns): Learn 5 essential patterns for structuring React state effectively. Discover how to group related data, avoid contradictions, eliminate redundancy, and keep your components maintainable and bug-free.
- [Nuxt Essentials: A Practical Cheatsheet for Beginners & Returners](https://certificates.dev/blog/nuxt-essentials-a-practical-cheatsheet-for-beginners-returners): A practical, beginner-friendly Nuxt 3 cheatsheet — updated for 2025. Covers plugins, composables, middleware, Nitro, Vite, Pinia, and more to help you quickly get back up to speed.
- [Getting Started With Provide/Inject In Vue.js](https://certificates.dev/blog/getting-started-with-provideinject-in-vuejs): Explore what’s beyond props and events with Vue's powerful Provide/Inject API. This article teaches you how to escape prop drilling and build cleaner, more maintainable components with type safety, and advanced patterns.
- [Event Delegation: One Listener to Rule Them All](https://certificates.dev/blog/event-delegation-one-listener-to-rule-them-all): Learn how event delegation in JavaScript lets you use a single event listener to handle clicks on multiple child elements efficiently—ideal for dynamic UIs and better performance.
- [Nuxt 4 is coming out, what does it mean?](https://certificates.dev/blog/nuxt-4-is-coming-out-what-does-it-mean): Nuxt 4 (alpha) launched in June 2025 with a stable release on the horizon — bringing a smooth, stress-free upgrade path from Nuxt 3. Unlike past painful rewrites, Nuxt 4 builds on a solid foundation with improved developer experience, and it’s worth migrating now before Nuxt 5 arrives.
- [Component Purity and StrictMode in React](https://certificates.dev/blog/component-purity-and-strictmode-in-react): Learn why keeping React components pure is essential for predictable behavior. Discover how StrictMode helps catch side effects and follow best practices for writing clean, maintainable components.
- [Understanding Vue.js Directives](https://certificates.dev/blog/understanding-vuejs-directives): Learn Vue.js directives with this guide. Understand their role, learn to create custom directives, and discover practical use cases and the best practices of using them in your projects.
- [Discover what it takes to be React Certified](https://certificates.dev/blog/discover-what-it-takes-to-be-react-certified): The program is designed to validate your competence through real-world coding challenges prepared and reviewed by industry leaders. To help you get ready for the exams, we have developed preparation guides that will give you specific insight into the area of knowledge that you have to have to successfully be certified.
- [Meet Your Examiner](https://certificates.dev/blog/meet-your-examiner): We're excited to announce that our React Certification content has been developed in collaboration with Aurora Scharff. This is a fantastic opportunity to transform your web development skills and become a certified React expert.
- [Vue.js Certification Success Stories: Real Developers, Real Results](https://certificates.dev/blog/vuejs-certification-success-stories-real-developers-real-results): Discover how Vue.js certification goes beyond resume-building, offering developers deep insights into frameworks, reinforcing core knowledge, and introducing best practices. Learn from real developer experiences about how our certification process elevates skills and enhances real-world application.
- [Black Friday Deals for JavaScript Developers](https://certificates.dev/blog/black-friday-deals-for-javascript-developers): "Unlock career-boosting certifications this Black Friday with up to 54% off on JavaScript, Vue.js, Angular, and Nuxt certifications from Certificates.dev. Validate your skills and gain a competitive edge in the tech industry with expert-led courses and recognized credentials
- [Answers to Common Questions About the Exam](https://certificates.dev/blog/answers-to-common-questions-about-the-exam): Let’s answer a few common questions about taking an exam on certificates.dev
- [Certification Matters](https://certificates.dev/blog/certification-matters): Ensure your skills are current and industry-recognized. Learn how Vue.js Certification keeps you prepared for the latest changes in the framework, and why staying certified is essential in a constantly evolving ecosystem.
- [JavaScript Certification: Your Key to Framework Adaptability](https://certificates.dev/blog/javascript-certification-your-key-to-framework-adaptability): Discover how JavaScript certification lays the groundwork for mastering popular frameworks like Vue, Angular, and React. Learn strategies for adapting quickly in a dynamic tech landscape while enhancing your career prospects.
- [Render Functions Explained - Senior Vue.js Developer Exam](https://certificates.dev/blog/render-functions-explained-senior-vuejs-developer-exam): Render functions provide a low-level method of defining Vue.js components. They allow you to work directly with the virtual DOM. In this article, learn how to wield them to your advantage.
- [How Exam Proctoring Works on Certificates.dev](https://certificates.dev/blog/how-exam-proctoring-works-on-certificatesdev): In this post, we cover proctoring methods for our developer certifications. Learn about how we leverage video monitoring, screen recording, and AI-assisted verification to a fair examination.
- [JavaScript Security: Protecting Your Applications from Modern Threats](https://certificates.dev/blog/javascript-security-protecting-your-applications-from-modern-threats): Explore essential JavaScript security practices to protect your web applications. Learn how to prevent common vulnerabilities like XSS and CSRF, implement secure communication, manage dependencies safely, and secure client-side data storage. Improve your app's defenses against modern threats.
- [Performance Optimization Techniques for Vue.js Applications](https://certificates.dev/blog/performance-optimization-techniques-for-vuejs-applications): Make your websites/apps fast with strategies like lazy loading, stable prop design, virtual lists, v-once and v-memo, plus more!
- [JavaScript Performance Optimization: Techniques for Blazing Fast Applications](https://certificates.dev/blog/javascript-performance-optimization-techniques-for-blazing-fast-applications): Improve your JavaScript performance with practical techniques. Learn about efficient memory use, smart DOM handling, and effective code splitting. See how these methods can speed up your web apps and enhance user experience.
- [What you need to know to be a successful JS dev](https://certificates.dev/blog/what-you-need-to-know-to-be-a-successful-js-dev): Explore essential JavaScript skills for junior and mid-level developers. From core concepts to advanced features, learn what's needed to build robust web applications. Find out how to validate your expertise and grow your career in web development.
- [Mastering Asynchronous JavaScript: From Callbacks to Async/Await and Beyond](https://certificates.dev/blog/mastering-asynchronous-javascript-from-callbacks-to-asyncawait-and-beyond): Explore the evolution of asynchronous JavaScript, from callbacks to Promises and async/await. Learn how these developments have transformed coding practices, making web apps more responsive and efficient. Discover advanced concepts and glimpse the future of async programming.
- [The Evolution of JavaScript: From Simple Scripting to AI and Beyond](https://certificates.dev/blog/the-evolution-of-javascript-from-simple-scripting-to-ai-and-beyond): Journey through JavaScript's evolution, from basic scripting to powering complex web apps and AI. Discover how this versatile language has transformed web development, expanded to server-side programming, and continues to shape the future of technology.
- [Angular Certification: A Roadmap for Continuous Learning and Growth](https://certificates.dev/blog/angular-certification-a-roadmap-for-continuous-learning-and-growth): Discover how the Angular Certification program comprehensively validates your skills across the framework's ecosystem. Learn how this expert-designed assessment benchmarks your proficiency from core concepts to advanced techniques.
- [What Does It Take to Pass the Certification?](https://certificates.dev/blog/what-does-it-take-to-pass-the-certification): Want to become an officially certified Vue.js developer? Get the low-down on what resources are available to help you pass the exam!
- [Angular Certification Costs in Context: Comparing Options Across Tech Certifications](https://certificates.dev/blog/angular-certification-costs-in-context-comparing-options-across-tech-certifications): Unlock your potential with Angular Certification, crafted by Google Developer Experts. Discover tiered options for every career stage, from junior to senior developers. Learn how our globally recognized program adapts to your needs with flexible pricing and expanded resources.
- [Angular Certification: Navigating the Framework's Ecosystem](https://certificates.dev/blog/angular-certification-navigating-the-frameworks-ecosystem): Explore the Angular ecosystem through the lens of certification. From components to Signals, learn how these elements interconnect in real-world development.
- [From Junior to Senior: Propel Your Angular Career Path with Certification](https://certificates.dev/blog/from-junior-to-senior-propel-your-angular-career-path-with-certification): Discover how Angular Certification levels—Junior, Mid-level, and Senior—can advance your development career. Learn what each level entails and gain expert insights on how certification can open new opportunities in the world of Angular development.
- [Tips for Nailing the Vue.js Certification Code Challenges](https://certificates.dev/blog/tips-for-nailing-the-vuejs-certification-code-challenges): Want to ace the Vue.js Certification? Besides the obvious knowledge of knowing Vue it might be helpful to know what to expect from the testing platform. Use these tips to avoid issues during exam coding challenges!
- [Angular Certification: A Growing Standard for Front-End Development](https://certificates.dev/blog/angular-certification-a-growing-standard-for-front-end-development): Developer Certification is gaining global interest, with developers from nearly 100 countries ready for their Angular Certification. Learn how this program, trusted by industry leaders, addresses common Angular challenges and provides structured paths for skill development and validation.
- [Angular Certification Program Joins Certificates.dev](https://certificates.dev/blog/angular-certification-program-joins-certificatesdev): Discover how the revamped Angular Certification program on Certificates.dev offers enhanced credibility through proctored exams and expert-led resources. Join the early access launch on July 30th and enhance your Angular skills with industry-recognized certification.
- [What Do Multiple Choice Questions Look Like for the Vue.js Certification?](https://certificates.dev/blog/what-do-multiple-choice-questions-look-like-for-the-vuejs-certification): Prepare effectively for the Vue.js Certification Exam by understanding the multiple choice section. Learn about the 30 randomized questions, their format, and tips for navigating and reviewing answers. Pass confidently by mastering the question structure and key Vue.js concepts.
- [The Vue.js Certification: What's in it For Employers and Devs](https://certificates.dev/blog/the-vuejs-certification-whats-in-it-for-employers-and-devs): In today's rapidly evolving tech landscape, staying ahead of the curve is paramount for both employers and developers. Vue.js, with its simplicity and versatility, has emerged as a popular choice for building dynamic web applications. However, amidst the multitude of frameworks and libraries, how do you ensure proficiency and credibility? Enter Vue.js certification - a great offering for employers and developers alike.
- [What to Expect When Taking the Vue.js Certification Exam](https://certificates.dev/blog/what-to-expect-when-taking-the-vuejs-certification-exam): In this article, I want to share with you what to expect from a platform perspective. In other words, we’ll ask the question “What is it like to take the test” and not “what do I need to know to pass the test”.
- [Year End Wrap Up](https://certificates.dev/blog/year-end-wrap-up): In February 2023, the Official Vue.js Certification was introduced. Explore this blog post to learn about the significant impact the program has had on the community and its substantial contributions.

## Legal

- [Terms & Conditions](https://certificates.dev/legal/cert-terms-conditions)
- [Privacy Policy](https://certificates.dev/legal/cert-privacy-policy)

## Notes

- Authenticated pages (/dashboard, /exam, /voucher, /editor) are not linked here — they require login.