Vue
Composition API with fine-grained reactivity and a progressive adoption path.
Vue's progressive model means you can introduce it into an existing codebase incrementally — a single component, a widget, or a full SPA — without committing to a full rewrite. The reactivity system tracks dependencies at a granular level, and the Composition API gives you an explicit way to co-locate logic without coupling it to the component lifecycle.
I write Vue 3 components with `<script setup>` and explicit TypeScript throughout — typed `ref<T>()`, `computed<T>()`, and `defineProps` with runtime validators where the types aren't sufficient on their own. Composables follow a single-responsibility pattern: one composable owns one slice of state or one async concern, and the return shape is typed so callers don't have to guess what they're getting back. I use `provide`/`inject` sparingly — primarily for cross-cutting concerns like theme tokens or a shared form context — because overusing it makes the data flow hard to trace. The reactivity pitfalls I've hit most often are losing reactivity by destructuring a reactive object without `toRefs`, registering watchers with the wrong `flush` timing (causing either stale reads or unnecessary re-renders), and forgetting that `reactive()` unwraps nested refs automatically while `ref()` does not. For Vue 2→3 migrations I use the official migration build as a compatibility layer, convert components file-by-file using `script setup` alongside the Options API during the coexistence period, then remove the compat config flags one at a time as each component is validated. That approach keeps the app shippable throughout the migration rather than doing a big-bang rewrite.
Vue 2 to Vue 3 Migration
I start migrations with the official Vue 2.7 compatibility build to get `<script setup>` and Composition API into the existing codebase before touching any components. From there, individual components are converted file-by-file — Options API and Composition API coexist safely during the transition period. Compat flags get removed incrementally as each component is validated, keeping the build shippable throughout.
Nuxt.js Setup
Rendering mode decisions depend on the content access pattern: static generation (`nuxt generate`) for fully cacheable pages, SSR for user-specific or frequently updated content, and hybrid routing when both are needed in the same app. I configure `useFetch` vs. `useAsyncData` based on whether the fetch needs to be key-deduplicated across navigations, and set the Nitro deployment preset to match the target runtime — Node server, Cloudflare Workers, or static CDN.
Component Architecture
I design composables around a single responsibility — one composable owns one async resource or one piece of derived state, and returns a typed shape so callers get autocomplete and don't have to inspect the implementation. I avoid over-extraction: if two lines of reactive state don't need to be reused, they stay in the component. `provide`/`inject` is reserved for genuinely cross-cutting concerns, not a substitute for prop drilling that would otherwise be straightforward.
Marketing & Content Sites
Nuxt 3 with static generation and file-based routing works well for content-heavy sites where pages are cacheable and SEO matters. The `<head>` management via `useHead` composable and built-in sitemap modules handle the metadata layer without additional configuration overhead.
Admin Panels & Dashboards
Vue's component model integrates cleanly with UI libraries like Vuetify, PrimeVue, and Element Plus, which provide data tables, form controls, and chart wrappers that expose Vue-native APIs. That reduces the amount of wrapper code needed to get feature-complete admin interfaces working.
Embedded Widgets
Vue can be bundled as a standalone IIFE and dropped into a server-rendered page without the rest of the application — no build pipeline changes required on the host side. The component mounts against a single DOM element and manages its own reactive state in isolation.
Let's talk Vue.
No pitch. Just a technical conversation about the problem you're working on.