Building a New Nuxt/Vue Platform and Migrating Legacy Purchase Flows

Context

The project involved building a new customer-facing Nuxt/Vue application while gradually replacing functionality from an existing legacy website.

The new application started from scratch, so the team needed both a solid engineering foundation and a safe way to move complex existing functionality without losing pages, behavior, or business rules.

I joined without previous professional Vue experience, became productive quickly, and took ownership across architecture, migration work, technical investigation, requirement clarification, implementation, testing, and delivery planning.

Foundational work

I helped establish the new application’s technical foundation before major product development began.

This included:

• testing setup with Vitest and Nuxt testing utilities
• comprehensive coverage requirements and CI enforcement
• linting, formatting, and type-checking
• pull-request validation
• build and deployment workflows
• CMS integration
• architectural decisions around Nuxt and static generation
• initial proof-of-concept implementation
• shared development patterns for the rest of the team

The goal was to give the new project a reliable baseline from the beginning rather than adding quality, testing, and delivery practices later as separate cleanup work.

Legacy purchase-flow migration

A major initiative involved moving all purchasing-related pages from the legacy website into the new application.

The old build process was highly convoluted, and the generated pages and embedded business rules were not documented to migrate safely by hand.

I researched the legacy implementation to understand how its purchasing pages were discovered and generated, then created a script that compared the old and new builds and verified complete page parity.

This turned a vague migration requirement into something measurable: the new application could be checked automatically for missing pages or variants.

After reaching page parity, I implemented the new version and wrote comprehensive tests to capture the existing business logic and expected behavior. With that safety net in place, I began refactoring and simplifying the inherited logic substantially while preserving the required outcomes.

Flexible product workflow engine

I also designed and built a flexible questionnaire and recommendation engine.

The workflow could branch indefinitely based on previous answers, apply conditional rules, and lead users through different paths before producing an appropriate product recommendation.

Rather than embedding the branching logic directly inside individual UI components, I represented the workflow and its conditions explicitly. This kept the rendering layer manageable and made the engine easier to extend, test, and reuse as requirements evolved.

Although the initial interface was implemented quickly, the underlying engine was designed as a general solution rather than a one-off linear wizard.

Requirement discovery and delivery planning

A large part of my contribution happened before implementation.

Requirements were often incomplete or spread across tickets, conversations, existing code, and knowledge held by different people. I regularly:

• ran technical spikes to resolve uncertainty
• researched the legacy implementation for hidden behavior and constraints
• contacted client stakeholders and domain experts for missing information
• asked targeted questions to expose edge cases and contradictions
• documented findings and technical implications
• broke work into clear, actionable tasks
• created tasks for other developers
• identified dependencies and delivery risks before implementation began

In several planning sessions, I effectively led the technical breakdown because I had already researched the work and prepared the tasks, descriptions, open questions, and dependencies needed for the team to move forward.

Outcome

The team gained a new Nuxt/Vue application with testing, CI/CD, code-quality checks, CMS integration, and clear development foundations established from the start.

The purchasing-related pages were migrated with automated verification that the new build matched the legacy system’s page coverage. Comprehensive tests preserved the required business behavior and enabled the inherited implementation to be simplified substantially without introducing regressions.

I was specifically praised for proactivity and ownership: investigating unclear work, finding the right people to answer missing questions, preparing tasks for other developers, and helping planning sessions move from broad goals to a concrete delivery plan.