Featured engineering case studies / Workforce budgeting

Attrition forecasting for an internal workforce budgeting platform

I took the backend work from the first stakeholder interviews to production in under four months. The released feature calculates monthly attrition and headcount restoration, includes the resulting workforce costs in budgeting scenarios, and sends the data to IBM Cognos Analytics.

Company
Avito
Role
Backend Engineer, L4
Contribution
Architecture, core backend, reviews and delivery
Stack
Go, PostgreSQL, IBM Cognos Analytics
Status
Released and in regular use

overview

Overview

The budgeting platform already modelled workforce positions and their monthly cost. It did not account for people leaving during a campaign or for the time and cost required to restore headcount.

C&B, FP&A and HR administration needed attrition to affect the same campaign calculations, comparisons and reports they already used. A separate spreadsheet or reporting-only calculation would have created another version of the budget.

context

Context

Attrition changes several monthly values at once. A person leaves, the position remains vacant for a period, and the company may later restore the headcount. Each step changes workforce cost and must remain consistent across calculations, campaign comparison and reporting.

The feature also had to work automatically across budgeting campaigns. Users should not have to maintain a parallel attrition model for every scenario.

constraints

Constraints

  • The new model had to fit the existing campaign and position domains.
  • Monthly calculations had to remain deterministic and testable.
  • Campaign comparison and reporting needed the same values as the main budgeting workflow.
  • The release had to preserve existing budgeting scenarios.

decision

Decision

I kept attrition inside the existing budgeting domain. The core model calculates the monthly reduction in active headcount and the later restoration step, then exposes those values to the services that calculate workforce costs.

This kept one calculation path for budgeting, campaign comparison and reporting. IBM Cognos Analytics receives the same result that users see in the budgeting workflow.

Architecture

Public system view

  1. 01Budgeting campaigns
  2. 02Attrition model
  3. 03Workforce cost calculations
  4. 04Campaign comparison and reporting
  5. 05IBM Cognos Analytics

The diagram uses public names only. Internal services and repositories are intentionally omitted.

role

My role

I started with stakeholder interviews and domain modelling, then wrote the technical design and implemented most of the backend. My work covered the core monthly model, integration with budgeting calculations, campaign comparison, reporting and delivery to IBM Cognos Analytics.

Two engineers handled bounded parts of the implementation. I defined the architecture, reviewed their changes and remained responsible for the final integration and release.

delivery

Delivery

The first tracked work began in May 2026. The feature reached production in September 2026. Most active backend implementation took place over roughly six to seven weeks within that period.

The release applied the new calculations automatically across campaigns. C&B, FP&A and HR administration began using the feature without material changes to the model after launch.

outcome

Outcome

Attrition became part of the normal budgeting workflow. Users can include monthly staff outflow and headcount restoration in workforce-cost projections, compare campaigns with the same calculation rules and use the resulting data in IBM Cognos Analytics.

lessons

Lessons

Keep one calculation path

Budgeting, comparison and reporting should use the same domain result. Reimplementing the model in each consumer would make discrepancies difficult to diagnose.

Validate the model with monthly examples

Month-by-month examples made stakeholder discussions and engineering reviews more precise. The same examples were useful when testing boundary conditions.

Delegate after the model is stable

The work could be split between engineers once the domain model and interfaces were stable. Architecture and final integration still needed one owner.