An IT studio’s owner closes the quarter and reviews a project that “went fine.” Invoiced to the client: 800,000 UAH. Spent on it: team salaries 540,000, design subcontractor 120,000, infrastructure 25,000, two feature rewrites 85,000. Margin — 30,000 UAH, or 3.7%. The plan was 30%.

The problem isn’t the project itself — the problem is that this calculation was done three months after kickoff. Had the owner seen the real margin in week 5, they would have rescoped, deferred the subcontract, or stopped the rework. But the numbers lived in three systems: a time tracker for hours, Excel for the budget, accounting software for invoices. Reconciling them is a separate 4-hour job at month-end you never quite get to on time.

Project accounting in ERPJS solves this differently: budget, timesheets, costs, and invoicing — all in one system, with margin in real time. Let’s break down how it works, what it gives small businesses, and where the honest limitations are.

(A note for readers in regions with different delivery infrastructure: the patterns here apply broadly to IT services, consulting firms, agencies, and engineering practices. Currency examples use UAH because most ERPJS customers operate in Ukraine, but the underlying mechanics are currency-agnostic.)

Why do you only find out about losses at the end of a project?

IT studios, agencies, consultancies, and engineering firms typically run on this stack:

• Toggl / Harvest / Clockify — team time tracking
• Excel or Google Sheets — project estimates and budget
• QuickBooks / accounting software — invoices to clients, payroll, taxes
• Jira / Asana / Trello — task management

Each system has its own data, formats, and owner. Once a month someone (usually the owner or finance person) consolidates it into a pivot — and that’s when it turns out the project that “looked profitable” is actually on the edge. Or past it.

Specific problems caused by fragmented systems:

• Delayed diagnostics. Margin is calculated 3-6 weeks after actual spend. By the time you see it, you can no longer course-correct — only document.
• “Invisible” expenses. A 50,000 UAH subcontractor invoice went through accounting but never made it to the project’s Excel sheet. It doesn’t show up in the project report.
• Double data entry. The PM enters hours into Toggl, then transfers them to a client report, then the bookkeeper builds an invoice. One hour, three entries, errors at every step.
• Time silently bleeds into “non-billable.” Code review, meetings, rework — plenty of hours, none invoiced. Without time classification you can’t see the productive-vs-non-productive ratio.
• T&M invoicing is a separate ritual. Export from Toggl, filter, copy sums, manual invoice. 30-40 minutes per project per month.

An owner of a studio with 10 developers and 5 parallel projects loses 8-12 hours a month just reconciling these systems. And still ends up with a delayed picture.

How does ERPJS structure a project?

A project in ERPJS is a dedicated record with required attributes and a live link to the rest of the company’s accounting.

What the project card stores:

• Code and name — for fast lookup and document linking
• Customer — link to the contact record; internal projects leave this empty
• Project type — configurable by you (e.g., development, support, marketing, research)
• Phases / stages — a dedicated directory that the budget uses (more below)
• Team — list of participants and up to five managers (project lead, tech lead, account manager, lead designer, etc.)
• Customer contact — no need to dive into the CRM
• Dates — start, planned finish, actual finish
• Status — active / completed
• Hierarchy — a project can be a sub-project of another (useful for programs)

The card isn’t just a profile — it’s a hub. Budget, timesheets, purchases, invoices, and tasks all attach to it. Everything that happens to the project is visible in one place.

How do you plan a project budget from scratch?

A budget in ERPJS is a dedicated document with a matrix of work items and materials. Not an Excel sheet — a real accounting document with history, versions, and approval.

What goes into the budget:

• Services and labor (lines with hours and rates)
• Goods and materials (with purchase and sale prices)
• Breakdown by phase — each line is tied to a project phase
• Discounts for the customer

The system automatically calculates from the budget:

• Total of labor
• Total of goods and materials
• Overall contract value
• Expected profit
• Margin in percent
• Markup

Budgets support versions. This is an important detail: you draft plan A, then after negotiations with the customer create plan B with reduced scope, then a final approved version. All versions are preserved — you can compare what changed.

A separate “Approved” status — until a manager approves the budget, it’s a draft. Once approved, it becomes the baseline for plan-vs-actual comparison.

How do you see which time actually goes to the client and which doesn’t?

This is the question every IT studio or agency owner asks themselves. The team logged 200 hours on a project, the invoice charges the client for 200 hours — and the margin is still thin. Why?

Because out of those 200 hours:

• Some — meetings and discussions (not always billable)
• Some — code review and bug rework (rarely billable)
• Some — wait time, blocked on client responses (overhead)
• Some — onboarding a new developer to the project (an investment, not revenue)

In ERPJS, every timesheet entry has not just a project and hours, but also a time class — a category you define yourself. It’s a flexible mechanism: you create the classes that fit your business.

Common examples of how companies break time down:

• Billable — hours that go into a client invoice
• Non-billable / not recognized by client — rework, mistakes, out-of-scope work the client won’t pay for
• Internal — meetings, training, R&D, documentation, company events
• Idle — downtime, waiting for access or client responses

Each class can be tied to its own rate via the client’s price list. The timesheet report automatically groups data by class — and the owner sees at a glance:

• How many of those 200 hours actually went into an invoice
• How much was “eaten” by rework — a signal to rescope or retrain the team
• How much went to internal work — that’s investment, not loss, but you need to know the size of it

Separately — internal projects. For time that doesn’t go to a client at all (R&D, internal automation, your own product), you create a project without a customer. Time goes into the same timesheets but stays out of client analytics. This lets you cleanly separate: work for clients vs. investment in the company.

You define the classification — there’s no imposed structure. A small agency might use 2 classes (billable / non-billable); a large IT studio might use 5-7 (development, code review, meetings, training, support, pre-sales, etc.). Timesheets are approved by a manager — only approved hours flow into reports.

What costs automatically end up in the project?

Project costs come from three sources and feed the profitability report automatically:

1. Team time. All approved timesheets are multiplied by employee rates to produce total labor cost. If you use multiple time classes, all of them feed into costs (because labor is labor) — but the report shows the breakdown.

2. Purchases and subcontracts. Every supplier invoice (subcontractor, materials, infrastructure) has a “Project” field. If the purchase was created from a budget line — the project is pre-populated, no selection needed. If it’s a standalone purchase (e.g., an extra tester for a sprint), the PM picks the project at creation time. This is standard analytics-tagging for transactions.

3. Materials from stock. If the project consumes inventory items (client hardware, server gear, kits) — their issue from stock is recorded with the project link.

All of this rolls up automatically into the “Project Information” report — no extra exports, no manual reconciliation.

How do you invoice clients — Fixed Price or Time & Materials?

ERPJS supports both.

Fixed Price (per phase). The budget contains work lines tied to phases. When a phase is delivered — an invoice is created from those lines. An “Invoiced” field records the invoice number, so you can see which budget lines are already billed and which aren’t. Good for projects with a tight scope and milestone-based payments.

Time & Materials (per hour). The invoice is built from approved timesheets for a period, multiplied by rates. A dedicated procedure picks all hours classed as “billable” for a chosen month (or week) and creates an invoice with a per-day breakdown. You can run this procedure manually at month-end, or put it on a cron — monthly T&M invoices are generated automatically from approved timesheets, and the owner just reviews them before sending.

You can mix models within a single project — for example, fixed price for the main phases plus T&M for a separate support hours pool.

Which report shows real-time project profitability?

The “Project Information” report is the manager’s main tool. It shows, for a single project or aggregated across all:

• Revenue — total issued and planned invoices
• Costs — team time × rates + purchases + materials
• Margin in money — Revenue minus Costs
• Margin in % — how profitable the project is

This report updates in real time. The moment a new purchase is posted or a timesheet is approved, the numbers shift. That means: the manager can open the report any day of the week and see how the project is doing today, not last month.

You can also build it by phase — and see that phase 1 is on-budget, while phase 2 is already 20% over plan. That’s a signal to act now, before phases 3 and 4 repeat the pattern.

An aggregate report across all active projects immediately surfaces the least profitable ones. The owner sees at a glance where the team is losing money and can replan resources.

How do you plan team workload ahead?

A dedicated tool — the Resource Manager, a calendar planner with three modes:

• Month — workload overview across the team for 30 days ahead
• Week — day-by-day detail within the week
• Day — hourly breakdown inside the workday

How it works:

1. Employees are registered in the system as resources — each has a code, a work schedule, role information
2. Projects have tasks — with start dates, deadlines, and a list of assignees (one or several per task)
3. Each task has a type — development, testing, meeting, design, code review — types are configurable with colors
4. The Resource Manager automatically renders a calendar grid: rows are employees, columns are dates, colored blocks in cells are tasks by type

What’s visible at a glance:

• Who is overloaded next week (row packed with blocks)
• Who has free slots (empty cells)
• How task types are distributed across the team (e.g., did all testing fall onto one person?)
• Who is doing what right now

Clicking a day in the month view switches to hourly detail. Double-clicking a block opens the task (description, project, assignees, status).

On top of that — task workflow: when a task is closed with a specific result, the system can automatically create a follow-up task. For example: “development” closed → “code review” auto-created for a different assignee. Or “testing” closed with “needs rework” → “development” goes back to the original developer. That’s lightweight workflow automation without needing a separate Jira or Asana for small teams.

Honest limitations:

• Gantt charts with task dependencies (“A can’t start until B finishes”) — not supported. Dependencies are expressed via automatic result-based transitions (workflow), not as hard date links
• An “estimated hours” field on a task — not supported. Only start and end dates; duration is derived from those. If you need precise per-task hour estimates, that’s a current-version limitation

For teams up to 30 people running 5-15 parallel projects, this is usually enough. If your style requires Gantt with a critical path — ERPJS isn’t that choice today.

How does ERPJS integrate project accounting with company finance?

This might be the most important difference from specialized PM tools like Jira or Asana. Project accounting in ERPJS isn’t a side module — it’s part of the company’s financial accounting.

How it works: every project-tagged document (client invoice, purchase, timesheet, material issue) automatically posts journal entries in the chart of accounts with a “Project” analytical dimension. That means:

• P&L can be built for the company with a project-by-project breakdown
• Cash Flow is visible both for the company overall and per project
• Accounts Receivable by project — how much each client owes for this specific project
• No parallel accounting needed: a number can’t live in the project system and not exist in the books

This is the “single source of truth” approach — versus the typical Toggl + Excel + accounting software combo, where each system knows only its slice and the owner reconciles manually.

For the basics of financial accounting, see our post on financial accounting. For automating management reporting, see management accounting automation.

Where to start: a 30-minute first-project plan

A realistic plan: by the end of one workday you have your first project with timesheets and a budget. More precisely, a 30-minute minimum skeleton — the team fills in details later.

Step 1 (5 min): create the project. Card — code, name, customer, dates, type. Fill required fields, save.

Step 2 (5 min): add the team. Pick employees from the directory. Assign one or two managers.

Step 3 (10 min): plan the budget. Create a budget document, add 5-10 main work lines (e.g., “backend development,” “UI design,” “QA,” “management”). Enter hours and rates. The system computes total, margin, markup.

Step 4 (5 min): configure time classes. If not already set up — create 3-5 basic classes (“billable,” “internal,” “rework” — names are yours).

Step 5 (5 min): onboard the team to timesheets. Show them the timesheet UI. Employees log hours by day with project, work type, and time class.

After a week, you have approved timesheets, project costs, and the first margin picture. After a month — stable analytics across all active projects.

Frequently Asked Questions