Project and Task Cost Methodology

Our platform automates financial analytics by combining data about real employee activity. We collect information through specialized plugins that track activity in the IDE, browser, terminal (CLI), database clients, and AI coding assistants, and map it against tasks from supported trackers (Jira, GitHub, and others). Based on this data, the system generates an honest and transparent development cost.

The diagram below shows the end-to-end flow — from raw activity to the final project cost:

1. Direct Costs

Direct costs are the foundation of all calculations — the actual cost of time recorded against a specific employee.

How we calculate

For each employee, we take the latest active rate valid in the period and apply one of two formulas:

• Hourly rate (HOURLY):

  cost = (seconds / 3600) × hourly_rate

• Monthly rate (MONTHLY):

  cost = (seconds / 3600) × (monthly_rate / 160)

  where 160 h is the standard working month (8 h × 20 days).

Activity sources

Activity is collected across five ActivityType categories: CODING, BROWSING, DATABASE, CLI, and AI_CODING. Data is aggregated through materialized views:

• mv_activity_total_user_project_daily
• mv_activity_total_user_issue_daily
• mv_activity_total_user_daily

Task-mapped vs. non-task activity, and how non-task is redistributed

An employee's activity splits into two types:

• Task-mapped — activity linked to a specific task (the issue_key from a Git branch or plugin context matches a tracker issue).
• Non-task — activity without a task link (meetings, reviews, planning, training, etc.).

:::important How non-task time lands on tasks Non-task time is not a separate overhead pool. For each employee with both task and non-task activity in the period, their non-task cost is redistributed across their own tasks in the same proportion as their direct task costs.

Example: an employee has 2,000 on Task A and 1,000 on Task B (2:1), plus 300 of non-task time. After redistribution, Task A gets +200 and Task B gets +100 — the 2:1 ratio is preserved.

This means direct_total for a task is the sum of direct task cost plus its share of redistributed non-task time. All downstream formulas use this blended direct_total. :::

2. Overhead (Indirect Costs)

Overhead captures costs that cannot be attributed to any task-bearing employee at all.

• Management / Admin Salary — the monthly salary of employees on a MONTHLY rate who have no recorded activity whatsoever in the reporting month (typically PM, CTO, HR). The salary is distributed proportionally to the number of days the rate was active within the month.

Non-task time of employees who do have activity never enters this pool — it has already been absorbed into direct_total via redistribution.

The diagram below summarises how each cost type reaches the project:

3. Allocation Method (Overhead Coefficient)

Overhead is distributed proportionally to the volume of direct costs using the following formula:

:::tip Formula

K = admin_salary / direct_total

Where:

• admin_salary — sum of pro-rated salaries of employees with zero activity in the month;
• direct_total — total direct costs of the department (task-mapped activity plus redistributed non-task time of active employees).

:::

Key properties

• Granularity: K is calculated per department and per month separately (enforced by a unique constraint department_id + year + month in the overhead_coefficient table).
• Arbitrary periods: for ranges spanning multiple months, a weighted average is used, with weights equal to direct_total of each month:

  K_eff = Σ(K_m × direct_total_m) / Σ(direct_total_m)

• Application: the final cost is computed month by month and summed:

  total = Σ(direct_m × (1 + K_m))

• Storage & recalculation: values live in the overhead_coefficient table and are refreshed by two cron jobs — a monthly job for the current month, and a full recalculation on startup and on the 1st of every month at 03:00.

Filters and exclusions

• Deactivated users (users.is_active = false) are excluded from direct costs (bugfix PDM-3369).

• Inactive department memberships (user_departments.is_active = false) are not counted.

• An overhead warning flag is raised when the system detects either:

  • MONTHLY rates above $50,000 on employees with no activity, or
  • employees with activity but no configured rate.

  Both cases signal a polluted K coefficient and require attention.

4. Worked Example

Consider one reporting month in a department with two active projects. All figures below already reflect the redistribution step from §1 — non-task time of active employees has already been folded into each project's direct cost:

• Project Alpha — direct costs (incl. redistributed non-task): 100,000
• Project Beta — direct costs (incl. redistributed non-task): 50,000
• Management salary with zero activity (admin_salary): 30,000

So direct_total = 150,000.

Step 1. Compute the coefficient:

K = 30,000 / 150,000 = 0.2  (20%)

Step 2. Apply it:

• Total cost of Alpha: 100,000 × (1 + 0.2) = 120,000
• Total cost of Beta: 50,000 × (1 + 0.2) = 60,000

note

The 100,000 and 50,000 figures are already "full" direct costs for each project. If the team logged, say, 20,000 of non-task time in the period, it is already distributed proportionally inside those two numbers — never added separately.

Why It Matters

This approach reveals not only the direct cost of code but also the real burden a project places on the company — including the share of management work that has no direct activity footprint. We are not an accounting service — our goal is to provide transparent and objective efficiency analytics based on automatic data collection.

---

note

Data is updated automatically when syncing with your development tools.