Web engineering / Vue
Vue development.
Web apps, dashboards and admin systems.
Build the browser workflows a business needs: customer portals, operations queues, analytics and SaaS screens. Design the API, access and rendering boundaries alongside the interface.
Discuss Vue requirements โContents ยท Vue
Design the workflow, its data and its access together.
A Vue web scope can include an admin panel, CRM, content management system, customer portal, operations dashboard or SaaS application. Start with the people who use it, the records they own and the decisions each screen supports. A table that loads quickly but shows the wrong tenant or silently overwrites a newer edit is not a successful implementation.
Identify browser routes, shared APIs, forms, file handling, exports, live events and the backend responsible for every rule. Include loading, empty, partial, stale, forbidden and failed states rather than treating them as finishing touches. Map the work to an inspected base product or custom specification, with clear acceptance, release and receiving responsibilities.
Agree what the receiving team can actually operate.
Name the source repository and history, dependency lockfiles, design assets, component inventory, API schemas, database migrations where included, test configuration, deployment settings and operating runbook. Distinguish Omnistu-authored work, client-supplied material and third-party packages or templates with their own licences. Repository delivery alone does not establish unrestricted rights to every asset.
Confirm who owns the backend, cloud accounts, domains, provider credentials and app-store releases. Define review access, confidentiality terms, acceptance, training, support responsibilities and the process for later upgrades in writing. A Vue admin interface does not by itself deliver a Flutter or React Native consumer application. Scope any shared API and mobile changes separately.
Compare frameworks against a representative product task.
Vue, React and Angular can be evaluated for forms, tables, routing and interactive dashboards. Compare supported dependencies, rendering choices, accessibility, state conventions, testing, team familiarity and ongoing ownership. Avoid turning a rendering model, ecosystem size or component syntax into an automatic speed or hiring advantage.
Vue single-file components and HTML-oriented templates may fit the team. Progressive adoption can fit an existing server-rendered page when Vue owns a clearly defined element and does not compete with another renderer. Existing React or Angular investment can also be a sound reason to stay with it. React Native pairing does not automatically make browser components portable, and a mobile app-store product needs a separate client strategy.
Seven decisions before a Vue development engagement.
What does the build include?
List components, layouts, composables, shared state, routes, API integration, authentication, permissions, tests and release operation. Specify whether TypeScript, CI checks, backend work and handover are included rather than accepting a proposal for screens alone.
In-house team, external team or both?
Name who owns architecture, code review, API changes, QA and release continuity. Compare relevant code and delivery evidence with the actual receiving team. An external initial build followed by internal ownership is an option, not a guaranteed staffing shortcut.
When is Vue a good fit?
Test a real form, queue or portal journey with the intended team and dependencies. An incremental jQuery replacement may be suitable where browser ownership can be isolated. A small content site may need less application infrastructure.
Can it handle data-heavy administration?
Evaluate query shape, pagination, filtering, table rendering and update volume on representative datasets. Pinia, virtualised lists and chart libraries are tools to assess, not proof that an unbounded browser workload will be responsive.
Where does Nuxt belong?
Consider initial HTML, server integration, hydration and per-route rendering as well as search discovery. Check actual response content and status codes. A framework choice does not guarantee ranking or secure a private admin route.
Can an existing system be migrated?
Audit Vue and library versions, plugins, routes, state, DOM integrations and release constraints. Preserve critical journeys through staged changes where practical. A migration plan must account for compatibility gaps and rollback, not promise invisible cutover.
What evidence should a buyer request?
Ask for permitted Vue code, a walkthrough of state and access boundaries, passing type and browser tests, production-like profiling, repository rights and an upgrade/runbook plan. Screenshots and a framework badge do not establish these capabilities.
Keep features, shared infrastructure and UI state distinct.
A feature folder can colocate its single-file components, composables, types, tests and relevant Pinia store. Shared infrastructure can hold API transport, session handling and reusable controls. Define dependency directions, public feature interfaces and a rule against one feature reaching into another store without an agreed contract.
A folder is not automatically a route chunk. Configure lazy routes with dynamic imports and verify the production build. Split expensive charts or editors where useful, including loading and retry behaviour for failed chunks. Shared components should expose explicit props and events; local state does not need to move into Pinia simply to avoid normal component communication.
Composition API with script setup and TypeScript is one coherent option. Options API remains supported, and Vue permits using both APIs in an existing codebase. Mixing them is not inherently a defect. Judge clarity, supported patterns and tests rather than labelling every Options component a required rewrite.
Give shared state a lifetime and an owner.
Pinia can hold shared client state such as a session projection, selected workspace and coordinated UI filters. Composables can share logic for pagination, validation or browser behaviour. Keep the backend authoritative for permissions and durable records. A browser role value is a display aid, not proof of access.
Do not ban fetching inside onMounted or watch as a blanket rule. Decide whether data belongs in a route loader, Nuxt data composable, query layer or a scoped effect. onMounted runs only in the browser; it will not provide server-rendered data. Define cache ownership, pending and error state, retries, cancellation and invalidation regardless of where a request starts.
With async watchEffect, only dependencies read before the first await are tracked automatically. Register supported cleanup at the right time: onWatcherCleanup in Vue 3.5 and later must be called synchronously before awaiting. Cancel obsolete requests or ignore their results so a slower previous filter cannot overwrite the current screen.
A vendor-indexed Pinia array is only a cache sketch.
The original useOrders setup store keeps byVendor as a reactive record and calls api.getOrders(vendorId) only when that entry is absent. This illustrates reuse between visits. It does not implement freshness, eviction or a complete request lifecycle. An empty array is also a cached result; a truthy-entry check can retain it indefinitely.
A usable contract needs explicit invalidation after creates, edits or refunds, a refresh policy and an identity that includes relevant workspace, filters, sorting and pagination. Two calls before the first response arrives may both fetch, so decide how to deduplicate in-flight work. Show loading, failed, empty and refreshing states separately and stop outdated responses from winning a race.
Validate external response data at runtime: an Order TypeScript type does not inspect incoming JSON. Authorise the actor and vendor on the server. A cache key does not create permission. Clear or partition data on logout, account switching and tenant changes, and avoid leaving previous records visible while the new context loads. Document whether an error preserves a clearly labelled stale result or clears it.
Choose static, browser or server rendering per route.
An authenticated SPA, static public catalogue and request-time page have different data and hosting needs. Nuxt supports universal, client-side and hybrid rendering, including route rules. It is not useful only for SEO. Evaluate initial content, server work, personalisation, deployment compatibility and hydration before choosing a mode.
Nuxt useFetch and useAsyncData can carry server-fetched data in the client payload to avoid repeating that initial request during hydration. Shared keys also share data, error and status; keep the associated handler and relevant options consistent. Include the actual data context in key design and define refresh behaviour rather than assuming a key is a permanent freshness policy.
Keep app, router and store instances isolated for each SSR request. Pass the appropriate Pinia instance when using stores outside a suitable setup context. Use the framework-supported safe serialisation path and inspect hydrated state: escaping protects HTML insertion but does not make browser payloads confidential. Never put secrets or another user's records into shared HTML, state or CDN caches.
Navigation guards are not server permission checks.
A route guard can redirect an unauthenticated visitor and hide unavailable controls. Every sensitive API read, mutation and export still needs independent session, role, tenant and record-level checks. Test direct API access, modified identifiers, expired sessions, forbidden actions and cross-tenant requests. Authentication alone does not settle whether this person may change that record.
Nuxt route rules and client middleware are not security boundaries. Redirects or proxies may be handled before server middleware, so enforce access at the protected endpoint or authoritative service. Apply deliberate caching rules to personalised responses and generated payload files, not only to the page URL.
Nuxt runtimeConfig.public is browser-visible; server-only runtime configuration can still leak if rendered into HTML or copied into client state. Do not put privileged credentials in browser bundles. Review uploaded files, rich-text rendering, dependency exposure, logs and exports. Record consent and retention needs separately from a claim of universal compliance.
Profile the actual table, chart and update path.
Inspect production-like builds for route JavaScript, network waterfalls, render work, interaction delay and memory growth. Use representative filters, row counts and update rates. Load charts only when the workflow needs them where the measured tradeoff supports it. A small development example is not an acceptance test.
shallowRef can avoid deep reactivity for a large immutable structure, but nested mutations do not trigger updates automatically. Replace the root value and follow an explicit immutable-update contract. v-memo depends on the dependencies supplied to it; omitting a value can leave stale output. It does not universally mean that a row rerenders only when its own data changes.
Virtual scrolling can reduce mounted rows but needs keyboard, focus, screen-reader and selection checks. Server pagination or aggregation may be more suitable than sending everything to the browser. For WebSockets, define authentication, reconnect, event order, duplicates, missed-event recovery and cleanup. Realtime transport alone does not keep every view correct.
Three service models, with boundaries written down.
- Admin base adaptation: inspect the actual base, licences, branding, modules and API compatibility before choosing reuse.
- Custom Vue product: agree architecture, frontend/backend scope, integration, testing, rollout and receiving-team operation.
- Ongoing development: define priorities, capacity, review/release ownership, support coverage and exit/handover terms.
Name responsibility for frontend, backend, QA and delivery coordination instead of inferring a staffed team from the model label. Confirm what is included beside customer and partner apps and what remains separate. Obtain an itemised written quote and acceptance plan; source-page prices, turnaround promises and support windows are not current commitments.
Six acceptance areas beyond component appearance.
- Architecture and review: feature boundaries, stores, composables, dependencies, access and runtime data validation.
- Automated checks: vue-tsc, unit/component tests, critical browser journeys and negative permission cases in CI.
- Browser and accessibility: agreed Chrome, Safari, Firefox and Edge coverage, responsive layouts, keyboard and assistive-technology checks.
- Performance: production-like bundle, table, chart and interaction checks against an agreed budget.
- Release operation: controlled configuration, preview/staging, safe deployment, logs and a tested recovery route.
- Support and observability: error reporting with private-data controls, access to useful source maps, ownership and response expectations.
A Vite TypeScript build transpiles code but does not perform type checking. Run vue-tsc or the agreed equivalent separately. Passing static types does not replace schema validation, browser tests or server authorisation. Describe what was tested and what remains unverified instead of calling any configuration production-ready by default.
Choose the dependencies the project can maintain.
- Vue: component model, templates and supported API conventions.
- TypeScript: compile-time contracts and separately enforced checks.
- Vite: development and build tooling, distinct from type checking.
- Vue Router: nested layouts, route data and explicit lazy imports.
- Pinia: shared client state with defined request/session lifetimes.
- VueUse: selected composables with browser and SSR behaviour reviewed.
- Tailwind CSS: responsive styling if it fits the design system.
- PrimeVue or Element Plus: assess tables, forms, accessibility, licensing and bundle impact.
- Nuxt: rendering, server integration and payload handling where appropriate.
- Axios or fetch: transport with authentication, cancellation and error contracts.
- Chart.js or ECharts: chart requirements, interaction and accessible alternatives.
- WebSockets: an event protocol and recovery plan, not just a connection.
- GitHub Actions or chosen CI: tests, previews and controlled release permissions.
- Vercel, AWS or chosen hosting: supported output, environment, cost and recovery.
- Sentry or selected observability: privacy-aware error and performance signals.
- Node.js API or existing backend: authoritative rules and validated integration boundaries.
Five stages from brief to an operable handover.
- Brief: people, records, workflow, confidentiality, devices, existing systems and account ownership.
- Scope: inspect base/custom fit, rendering, API contracts, acceptance, dependencies and itemised quote.
- Build and demonstration: review working journeys, code changes, errors and unresolved assumptions at agreed checkpoints.
- QA and polish: check supported browsers, responsive/accessibility needs, permissions and production-like behaviour.
- Release and handover: approve the target environment, verify the deployment, transfer documentation and arrange support ownership.
List prerequisites such as provider onboarding, API access, content, domain control and compliance review with named owners. A delivery schedule must include review and external dependencies rather than attributing every possible delay to the client. Agree application launch, paid hosting and domain-change responsibilities in the project scope.
Price modules, integration and operating responsibility.
The original distinguishes an admin base, custom SPA/SaaS dashboard and ongoing retainer. Keep those choices, but obtain a current written scope and quote instead of carrying historical prices or delivery ranges into a promise. Explain reusable versus custom work and which third-party charges remain separate.
- Module breadth: users, reporting, content, bookings, dispatch, payouts and audit.
- Data complexity: tables, filtering, charts, file handling, export and realtime feeds.
- Access: roles, tenants, delegated administration and record-level restrictions.
- Rendering: static output, server runtime, cache policy and public/private route split.
- Integrations: payments, CRM, ERP, provider APIs and reconciliation.
- Migration, accessibility, test coverage, hosting, monitoring, training and upgrade ownership.
Clarify billing milestones, acceptance, support, change requests and cancellation terms before committing. Do not assume a framework reduces every project cost or that a ready-made label proves the requested backend and mobile features already exist.
Modernise without treating every working pattern as obsolete.
Inventory Vue version, Vuex/Pinia usage, plugins, filters, event buses, build tooling, tests and DOM-dependent integrations. Vue 2 upstream support ended on 31 December 2023; the official FAQ also identifies an extended-support option. Verify the actual dependency support arrangement rather than claiming that no security support can exist.
Vue 3 still supports Options API. Keep compatible components where appropriate and move shared logic, state and TypeScript in deliberate steps. Evaluate Vuex-to-Pinia changes against behaviour and contracts, not only file names. Replace unsupported plugins and test accessibility, navigation and stored data compatibility.
For jQuery coexistence, establish which code owns each DOM region, events and cleanup. Plan releases with rollback and user-visible acceptance checks. Confirm supported Vue/Nuxt versions, dependency replacements and hosting adapters when implementation starts.
An EdTech dashboard is a scope example, not a verified result.
The source describes a teacher, student and parent administration product with grade feeds, attendance, curriculum management and analytics. Preserve the three-role requirement while treating the location, pilot scale, delivery date and launch story as unverified illustration, not client evidence.
A candidate design uses Vue/TypeScript feature modules, Pinia state, lazy Vue Router routes and PrimeVue tables. Public course catalogue routes can be evaluated for Nuxt rendering, with an agreed Node API or existing backend. Shared types can help describe contracts; they do not enforce field validation or determine who may see a student record.
Acceptance should cover relationships between students and parents, teacher class permissions, attendance corrections, grade publication, curriculum changes, exports and accessible charts. Define live-event reconciliation, audit history, privacy controls, staging data and recovery. Ask for a permitted running demo and test record before accepting the scenario as evidence of completed delivery.
Vue delivery review and handover.
Ask for relevant repository access or a permitted code walkthrough, not private client material. Inspect composable/store boundaries, API authorisation, CI results, runtime response handling, browser tests and production-like profiles. Request a dependency inventory and a demonstration of a failed request, session change and forbidden action.
Agree the implementation boundary, deliverables and acceptance checks in the project scope. Include the source and configuration to be handed over, third-party dependencies, account ownership and the receiving owner's installation and operating walkthrough. Review the selected work at the agreed milestones, with unresolved items recorded before release.
Turn each sector into specific data and workflow questions.
- Healthcare and life sciences: patient/booking workflows, minimum data access and separate regulatory review.
- Telemedicine: intake/provider administration distinct from secure clinical consultation delivery.
- Banking and finance: review queues, transaction state, reconciliation and audit permissions.
- Cryptocurrency: wallet/network integrations, custody boundaries and risk review beyond a browser dashboard.
- eCommerce: products, orders, inventory, returns and payment reconciliation.
- Food and grocery: availability, fulfilment, dispatch, refunds and live operational status.
- Logistics and transport: routing, partner records, location privacy and exception handling.
- Travel and hospitality: listings, availability, bookings, supplier integrations and cancellations.
These are planning categories, not certifications or installed products. Test representative workflows and independently verify provider terms, business rules and sector obligations before launch.
Questions to settle before Vue work.
Can Vue administration work beside mobile apps?
It can be designed around shared APIs, but identify the actual mobile technologies, contracts and version compatibility. Browser components do not automatically become native mobile screens.
Must every public page use a server?
No. Compare static output, request-time rendering and browser rendering against route data and deployment needs. Inspect initial HTML and metadata rather than promising search results from a framework name.
Is Pinia required for every piece of state?
No. Keep local UI state local when appropriate. Use shared stores or data layers where coordinated ownership and lifetimes justify them. Normal props and events are not architectural failure.
Does the guide include a live admin or a quote?
Request a demonstration of the relevant application base and an itemized written proposal covering scope, dependencies, rights, acceptance and quote. Identify the payment, admin and realtime backend work separately, with actual account and operating owners.
Primary references for the technical checks.
Official Vue, Pinia and Nuxt references checked on 17 November 2026. Confirm the supported dependency set and deployment behaviour again for an actual build.
- Server Side Rendering (SSR) | Pinia
- Using a store outside of a component | Pinia
- Nuxt | Pinia
- Performance | Vue.js
- Server-Side Rendering (SSR) | Vue.js
- Composition API FAQ | Vue.js
- Watchers | Vue.js
- State Management | Vue.js
- Using Vue with TypeScript | Vue.js
- Frequently Asked Questions | Vue.js
- Data Fetching
- Rendering Modes
- Runtime Config
- Sessions and Authentication
Bring the workflow and the rules behind the screen.
Describe users, records, access, rendering, data freshness and integrations. Agree the base/custom split, evidence, testing, migration, quote and receiving-team handover before implementation.
Discuss Vue requirements โ