All work

Five modules for a company that ran on spreadsheets

The project support team ran projects in Google Sheets with VBA macros, accounting lived in Excel, and office managers planned seating on paper. Over eighteen months I built them five modules of one Nuxt system as the team’s only frontend developer.

Platforma. IT Solutions
Architecture and construction, Yekaterinburg
Information systems developer
April 2025 — present
25,000+
rows in the project schedule with all five levels open
2,500
documents in the acts and invoices register
6
offices on the map, 2–3 floors each, 50–100 desks per floor
up to 500
people worked in the ERP at the same time on peak days

Nineteen months, five modules

I worked on the ERP alongside everything else from day one. The other modules I built one at a time, in the order shown.

With a lead developer Independent, team lead review ERP 01 Office planner 02 Project schedule 03 Acts register 04 Finance plan Apr 2025 now

What people used before

Office planner

Users
Office managers
Before
Seating plans on paper
After
A native SVG map: people and equipment at desks across six offices

Project schedule

Users
Project support team, who handle paperwork for the designers
Before
Google Sheets with VBA macros. The sheet lagged and the macros made mistakes
After
A 25,000-row table with five nesting levels and the Excel shortcuts people already knew

Acts and invoices register

Users
Accounting
Before
Excel and Google Sheets with the same problems
After
A register of 2,500 documents: templates, PDF and DOCX uploads, in-cell editing

Finance plan

Users
Management, for quarterly and yearly planning
Before
Superset and similar BI tools. The data was too specific, and they had no snapshots, approvals or comments
After
A table and a Gantt chart with synced scrolling, export and real-time collaboration

ERP module

Users
The whole company
Before
Off-the-shelf ERPs that would need long customisation for the company’s narrow processes
After
Timesheets, tasks as Kanban, table and Gantt, leave requests with approval

My favourite module

A 25,000-row project schedule

This is where I first thought hard about rendering a lot of data. With all five levels open, the table grows to 25,000 rows and 20 columns. A browser can’t handle that many DOM nodes, so I render only the rows in view and load nested levels when someone opens them.

Users came from Google Sheets and expected it to behave the same way. The table supports arrow keys, block copy and paste, drag-to-fill and in-cell editing. TanStack Query caches the data. An edit shows up at once and rolls back if the server rejects it.

The project also had exemplary code hygiene: strict ESLint, pre-commit hooks and a clear module structure.

Reconstruction

14 rows14 in DOM

Name
Code
Owner
Status
Due
Plan, sh.
Done, sh.
Progress

Expand everything and watch the counter. Move around with the arrow keys, drag a value by the cell corner, copy a block and paste it elsewhere. Switch the network to “Flaky” and edit a cell.

A story

The great children escape

The funniest bug in the project schedule. The server sent a tree where every row had a children array holding the next level. Sometimes the query cache drifted from what the backend had, the store crashed, and nested rows vanished from the table. Hence the name.

We changed the transport. The server started pushing changes over WebSocket, and I patched them into the query cache one by one. The client showed its own edits optimistically and rolled them back on error.

Before: refetch the whole tree
  1. Edit a row
  2. Refetch the tree
  3. Cache and server drift
  4. children: [] — rows gone
After: targeted changes over WebSocket
  1. Edit shows at once
  2. Server confirms over WebSocket
  3. Patch lands in the query cache
  4. Rollback on error

The hardest module

A finance plan rebuilt four times

Management planned quarters and years in this module and spent a long time deciding how they wanted to see the data. It started as a plain Gantt chart. Then came the idea of pairing it with a table, and that version finally stuck.

To avoid rewriting the module a fifth time, I changed how I worked. I built each new idea as a quick prototype from open-source components and showed it in a meeting. Proper development, to spec and in the company style, started only after sign-off.

In the final version the table and the Gantt chart scroll in sync, colleagues’ edits arrive over WebSocket, and a snapshot freezes the plan on a date so you can compare it with the current one later.

  1. 01 Gantt only
  2. 02 Iteration 2
  3. 03 Iteration 3
  4. 04 Table + Gantt
Reconstruction
Irina K. finance director
Project and lineTotal
Northern Quarter housing
Income7 M ₽
Subcontractors2 M ₽
Payroll5 M ₽
School for 1,100 pupils
Income7.3 M ₽
Subcontractors1.6 M ₽
Payroll2.6 M ₽
Foundry Business Centre
Income5.2 M ₽
Subcontractors3.3 M ₽
Payroll920 k ₽
Garden Street Clinic
Income1.9 M ₽
Subcontractors2.2 M ₽
Payroll1.6 M ₽
Ice Arena
Income10 M ₽
Subcontractors3.9 M ₽
Payroll1.6 M ₽
Iset Tech Park
Income5.3 M ₽
Subcontractors1.7 M ₽
Payroll1.3 M ₽
Balance, M ₽
JanFebMarAprMayJunJulAugSepOctNovDec
1,170/mo
510/mo
830/mo
1,460/mo
820/mo
520/mo
1,040/mo
650/mo
460/mo
950/mo
430/mo
540/mo
2,000/mo
650/mo
820/mo
1,050/mo
280/mo
440/mo
0 0.5 -0.7 -0.1 0.3 1.4 -0.4 0.7 3.3 2.9 0.9 0
WebSocket connected

Drag a bar to another month or stretch it by its right edge. A colleague is editing the plan too, and her changes arrive on their own. Press “Take snapshot”, change a couple of rows and see where the plan drifted from it.

The first module

Seating plans off paper

This is where I started. Office managers tracked equipment and seated people on paper, and at the peak the company had six offices with 2–3 floors and 50–100 desks each.

I wrote the map in native SVG with my own logic: you assign a person or equipment to a desk, and the office manager sees right away what is free.

Reconstruction

4 taken of 32

01AS03040506GT0809101112VL1415161718192021OM23242526272829303132

Pick a person and click a free desk, or drag them onto it. Click a taken desk to see what is on it.

Two more modules

Acts and invoices register

Accounting kept project documents in Excel. The register grew to 2,500 of them. Acts and invoices come from a template or by hand, PDF and DOCX files upload straight into the record, and amounts are edited in cells like in a familiar spreadsheet.

ERP module

The company first looked at off-the-shelf ERPs, but any of them would need long customisation for its processes. Our module grew with all the others from day one: timesheets, tasks as Kanban, table and Gantt, leave requests with approval. On peak days up to 500 people used it at once.

How it fits together

All five modules live in one Nuxt application and share a common layer: the query cache, the WebSocket channel and a Naive UI theme I adapted to the company style. Linters, pre-commit hooks and Nuxt deployments were on me too.

Office planner Project schedule Acts register Finance plan ERP Nuxt 3 · SSR one monolith TanStack Query cache and optimistic UI WebSocket schedule and finance plan Naive UI in the company style ESLint · pre-commit · deploy tooling

How I worked

For the first six months I worked under a lead developer, then on my own with team lead review, and I reviewed my colleagues’ code.

Often there was no spec. I sat in review meetings with management and clients and gathered requirements straight from the people who would use the system. Their feedback was positive across the board.

Technologies

The company’s interfaces are private, so the demos on this page are my own reconstructions with fictional data. No product code, data or design made it here.