Odoo 19 for
Professional Services

Your Consultants Are Busy. Your Billing Says Otherwise.

Every professional services firm we've onboarded shares the same complaint: the team is working at full capacity, but revenue doesn't reflect it. Timesheets are submitted late (or not at all), project managers don't know who's available next week, and invoices go out weeks after the work was delivered — often missing billable hours that were never logged.

The gap between work performed and revenue captured is called revenue leakage, and in professional services it typically runs between 5% and 15% of total billable hours. For a 50-person consultancy billing at $150/hour, that's $1.5M–$4.5M in annual revenue that simply evaporates because the operational systems can't keep up with the delivery team.

Odoo 19 addresses this with a tightly integrated Project + Timesheet + Invoicing + Planning stack that eliminates the manual handoffs where billable hours get lost. This guide walks through the complete configuration — from setting up billing models (T&M, fixed-price, retainer) to building profitability dashboards that show margin by project, client, and consultant in real time.

Timesheet Entry, Approval Workflows, and Billing Rate Overrides in Odoo 19

Timesheets are the revenue engine of a professional services firm. Every hour that isn't logged is an hour that can't be billed. Odoo 19's timesheet module has improved significantly — with grid view for weekly entry, timer-based tracking, manager approval workflows, and automatic billing rate computation.

Configuring the Approval Workflow

Enable timesheet approval under Timesheets → Configuration → Settings → Timesheet Approval. Once enabled, submitted timesheets require manager validation before they can be invoiced. This prevents billing errors from reaching the client.

from odoo import models, fields, api
from datetime import timedelta

class TimesheetReminder(models.TransientModel):
    _name = 'hr.timesheet.reminder'
    _description = 'Weekly Timesheet Reminder'

    @api.model
    def _send_missing_timesheet_reminders(self):
        """Cron job: remind employees who logged < 32h this week."""
        today = fields.Date.today()
        week_start = today - timedelta(days=today.weekday())

        employees = self.env['hr.employee'].search([
            ('company_id', '=', self.env.company.id),
            ('employee_type', '=', 'employee'),
        ])

        for emp in employees:
            logged = sum(
                self.env['account.analytic.line'].search([
                    ('employee_id', '=', emp.id),
                    ('date', '>=', week_start),
                    ('date', '<=', today),
                    ('project_id', '!=', False),
                ]).mapped('unit_amount')
            )

            if logged < 32.0:  # Less than 4 days logged
                template = self.env.ref(
                    'my_module.email_timesheet_reminder'
                )
                template.send_mail(emp.id, force_send=True)

        return True

Billing Rate Overrides by Employee or Role

Not every consultant bills at the same rate. A senior architect at $250/hour and a junior analyst at $95/hour may both work on the same project. Odoo 19 supports employee-level billing rate overrides through the timesheet_cost field and sale order line pricing. Configure rate tables under Project → Configuration → Settings → Pricing to set different rates per employee, per project, or per task type.

Resource Planning and Allocation: Scheduling Consultants Across Projects in Odoo 19

The Planning module is where professional services firms gain the most operational visibility. It answers the question every delivery manager asks on Monday morning: "Who is available, and where should I put them?"

Odoo 19's Planning module provides a Gantt-style view of resource allocation across projects, with drag-and-drop scheduling, conflict detection, and capacity forecasting. Shifts (allocations) are tied to projects and tasks, so when a consultant is assigned to a project phase, it shows up in their personal schedule and the project's resource plan simultaneously.

from odoo import models, api
from datetime import timedelta

class SaleOrder(models.Model):
    _inherit = 'sale.order'

    def action_confirm(self):
        res = super().action_confirm()
        self._create_planning_shifts()
        return res

    def _create_planning_shifts(self):
        """Auto-create planning shifts when an SO is confirmed."""
        Planning = self.env['planning.slot']

        for line in self.order_line.filtered(
            lambda l: l.product_id.service_tracking
                      in ('task_in_project', 'project_only')
        ):
            project = line.project_id or line.task_id.project_id
            if not project:
                continue

            # Calculate shift duration from estimated hours
            hours = line.product_uom_qty
            days_needed = max(1, int(hours / 8))

            Planning.create({
                'project_id': project.id,
                'task_id': line.task_id.id if line.task_id else False,
                'resource_id': False,  # Unassigned — PM allocates
                'allocated_hours': hours,
                'start_datetime': fields.Datetime.now(),
                'end_datetime': fields.Datetime.now()
                    + timedelta(days=days_needed),
                'role_id': self._get_default_role(line).id,
                'state': 'draft',
            })

The workflow above creates unassigned planning shifts when a sale order is confirmed. The project manager then drags these into specific consultant calendars using the Planning Gantt view. This ensures no confirmed project falls through the cracks — every sale immediately creates a resource demand that needs to be fulfilled.

Capacity vs. Demand Dashboard

Navigate to Planning → Planning by Resource to see each consultant's allocation. Odoo 19 color-codes capacity: green (< 80% allocated), yellow (80–100%), red (> 100% overbooked). A delivery manager can spot overallocation instantly and redistribute work before it causes burnout or deadline slippage.

Expense Management: From Receipt to Client Reinvoicing in Odoo 19

Professional services projects often include reimbursable expenses — travel, software licenses, subcontractor fees. Odoo 19 connects expenses to projects and sales orders so that client-billable expenses flow directly into the project invoice alongside timesheet-based charges.

The configuration chain is: Expense Product → Analytic Account (project) → Sale Order Line → Invoice. When a consultant submits a travel expense tagged to a project, and that project is linked to a sale order with a "reinvoice expenses" line, Odoo automatically adds the expense to the next invoice at cost or with a markup.

Enable OCR receipt scanning under Expenses settings. Odoo 19's built-in OCR extracts the vendor, amount, date, and category from uploaded receipt photos — reducing manual data entry by 80%. The consultant snaps a photo of a dinner receipt, Odoo pre-fills the expense form, and the consultant just needs to tag the project and submit.

Approval Workflow for Expenses

Configure multi-level expense approval under Expenses → Configuration → Settings. For professional services, we recommend a two-tier flow: expenses under $500 require only the project manager's approval, while expenses above $500 also require finance team sign-off. This balances speed (consultants aren't blocked on small travel claims) with control (large expenses get financial oversight).

Once an expense report is approved, it creates a journal entry that debits the appropriate analytic account (the project). If the expense product is configured for reinvoicing, Odoo adds the amount to the project's "Costs to Re-invoice" section, making it available on the next client invoice. The entire chain — receipt upload to client billing — happens without a single spreadsheet.

Client Portal: Giving Clients Real-Time Project Visibility Without Email Chains

The number one cause of client dissatisfaction in professional services isn't poor work — it's lack of visibility. Clients want to know: How many hours have been used? Are we on track? What's the remaining budget? Without a portal, they ask via email, the PM compiles a spreadsheet, and the answer arrives 48 hours later.

Odoo 19's customer portal gives clients self-service access to:

• Project tasks — status, assignee, and deadlines for every deliverable.
• Timesheet entries — who worked on what, when, and for how long (if you enable timesheet visibility on the project).
• Invoices and payments — current billing status and payment history.
• Support tickets — if using Helpdesk, clients can submit and track tickets directly.
• Documents — shared project files and deliverables.

To enable timesheet visibility for portal users, navigate to Project → Configuration → Settings and enable "Timesheets on Customer Portal". Then on each project, toggle the "Timesheets" portal visibility option. Clients will see a summary of hours logged per task without needing to request a status report.

Profitability Analysis and Revenue Forecasting for Services Firms in Odoo 19

Revenue is vanity, margin is sanity. A project that bills $200,000 but consumes $190,000 in consultant time and expenses isn't a success — it's a warning sign. Odoo 19's Project Profitability view aggregates revenue (invoiced + uninvoiced timesheets) against costs (employee cost rate x hours + expenses) to show margin at the project, client, and portfolio level.

Navigate to Project → All Projects and click the Profitability button on any project. Odoo displays:

• Revenues — invoiced amount, amount to invoice (uninvoiced timesheets), and other revenue.
• Costs — employee timesheet costs (internal rate x hours), expense costs, purchase order costs, and other costs.
• Margin — revenue minus costs, shown as both an absolute amount and a percentage.

from odoo import models, fields, api

class ClientProfitabilityReport(models.TransientModel):
    _name = 'ps.client.profitability.report'
    _description = 'Client Profitability Report'

    date_from = fields.Date(required=True)
    date_to = fields.Date(required=True)
    partner_ids = fields.Many2many('res.partner')

    def action_generate(self):
        domain = [
            ('date', '>=', self.date_from),
            ('date', '<=', self.date_to),
        ]
        if self.partner_ids:
            domain.append(
                ('partner_id', 'in', self.partner_ids.ids)
            )

        timesheets = self.env['account.analytic.line'].search(
            domain + [('project_id', '!=', False)]
        )

        report_data = {}
        for ts in timesheets:
            partner = ts.project_id.partner_id
            if not partner:
                continue
            key = partner.id
            if key not in report_data:
                report_data[key] = {
                    'partner': partner.name,
                    'hours': 0.0,
                    'revenue': 0.0,
                    'cost': 0.0,
                }
            report_data[key]['hours'] += ts.unit_amount
            report_data[key]['revenue'] += (
                ts.unit_amount * ts.so_line.price_unit
                if ts.so_line else 0.0
            )
            report_data[key]['cost'] += (
                ts.unit_amount * ts.employee_id.timesheet_cost
            )

        # Calculate margin for each client
        for data in report_data.values():
            data['margin'] = data['revenue'] - data['cost']
            data['margin_pct'] = (
                (data['margin'] / data['revenue'] * 100)
                if data['revenue'] > 0 else 0.0
            )

        return report_data

Forecasting Revenue from the Pipeline

Combine CRM pipeline data with resource planning to forecast revenue. Every qualified opportunity with an estimated value and expected close date represents future resource demand. When that opportunity converts to a sale order, the planning shifts created at confirmation (from section 03) immediately show the impact on capacity. This creates a closed-loop forecast: sales pipeline → resource demand → capacity constraint → hiring decision.

Key metrics to track on your executive dashboard:

• Utilization rate — billable hours / total available hours. Target: 70–80%.
• Realization rate — invoiced revenue / (billable hours x standard rate). Measures discounting and write-offs.
• Revenue per FTE — total revenue / headcount. Industry benchmark: $150K–$250K for mid-market firms.
• Backlog — contracted but undelivered revenue. Shows how many weeks of work are secured.

class UtilizationCompute(models.Model):
    _inherit = 'hr.employee'

    utilization_rate = fields.Float(
        string='Utilization Rate (%)',
        compute='_compute_utilization',
        store=True,
    )

    @api.depends('timesheet_ids', 'resource_calendar_id')
    def _compute_utilization(self):
        today = fields.Date.today()
        month_start = today.replace(day=1)

        for emp in self:
            # Total available hours from work schedule
            calendar = emp.resource_calendar_id
            if not calendar:
                emp.utilization_rate = 0.0
                continue

            available = calendar.get_work_hours_count(
                datetime.combine(month_start, time.min),
                datetime.combine(today, time.max),
                resource=emp.resource_id,
            )

            # Billable hours from timesheets
            billable = sum(
                self.env['account.analytic.line'].search([
                    ('employee_id', '=', emp.id),
                    ('date', '>=', month_start),
                    ('date', '<=', today),
                    ('project_id.allow_timesheets', '=', True),
                    ('so_line', '!=', False),  # Linked to SO = billable
                ]).mapped('unit_amount')
            )

            emp.utilization_rate = (
                (billable / available * 100)
                if available > 0 else 0.0
            )

This computed field gives you a live utilization percentage on every employee record. Build a Pivot or Dashboard view on hr.employee grouped by department to see which teams are running hot and which have capacity. Combine this with the Planning module's forward-looking allocation data to distinguish between "utilized now" and "booked for next month."

3 Configuration Mistakes That Cause Revenue Leakage in Odoo Professional Services

Optimization Metadata