Modernizing a pricing intelligence SaaS inside a legacy Django product.

The business needed a more interactive product, but the existing Django app was the business: real customers, real workflows, no appetite for a risky rewrite. So the modern layer had to grow inside it. Each major product surface became its own Vue app, compiled by a multi-entry Vite build into Django's static files and mounted into the server-rendered page it belongs to.

A shared bootstrap keeps those apps feeling like one product. Every entrypoint gets the same Pinia setup, Quasar config, axios conventions, localization, motion, and directives from a single app-creation utility. The integration seams got real attention: the active locale is read from the Django-rendered page so translations follow the account language, and every request carries a per-tab ID header so the backend can tell browser tabs apart.

The product table is where pricing teams spend their day. One surface has to act as catalog browser, competitor comparison, export tool, and pricing console at once: global filters, table filters, quick filters, column preferences, saved views, date controls, and expandable competitor offer history all live on it.

The hard part was letting those dimensions combine without the table becoming fragile. A single Pinia store owns filter state, competitor columns, offer loading, saved views, and the export lifecycle, so every control stays consistent with the data on screen. Exports run in the background with status polling, retry, share, and download flows while the table stays usable.

Visual Analytics is the most ambitious surface: a charting workbench where users compose their own analysis instead of consuming fixed dashboard widgets. A chart combines up to three datasets with independent y-axes, drawn as line, bar, segmented bar, or boxplot.

Each dataset can be aggregated, segmented, and grouped across product, competitor, sales, and Dynamic Pricing dimensions, in static or over-time mode, with a ratio mode when exactly two datasets are selected. The chart and its data table share one configuration, so the same view supports visual exploration and spreadsheet-style analysis, with CSV and image export on top.

That configuration space made state and performance the real engineering problems. Heavy data transformation runs in a web worker to keep the UI responsive, and finished configurations can be saved as private views, shared with the team, or set as defaults.

Scheduled Reports turns the same data into recurring delivery for people who live in BI tools and spreadsheets. I built the report list and a multi-step create/edit wizard covering report type, setup, schedule, delivery method including SFTP, notification emails, column customization, and a confirmation overview, with timezone handling and validation throughout.

Dynamic Pricing is a rules engine, and the UI had to make its operational state legible rather than wrap it in generic CRUD screens. The interface covers group sets and groups, drag-based priority reordering, enable/disable states, settings, suggestion outcomes (raise, lower, keep, no price), and the price change log that shows what the engine actually did.

Where legacy Django pages still handled edge configuration, the new UI bridged into them instead of pretending they did not exist. Pragmatic seams like that were part of the migration strategy.

A product this dense needs explanation built in. I wrote and maintained the customer documentation as a VitePress site in English, French, and German, and built the in-app layer connecting it to the product: contextual help targets driven by a custom directive, guided tours for new users, and eleven short walkthrough videos embedded where the table workflows get complicated.

The same care went into the code itself: Vitest suites around the table and analytics stores guard the state logic that every other surface depends on.