diff --git a/hr_payroll_overtime/__init__.py b/hr_payroll_overtime/__init__.py
new file mode 100644
index 00000000..0650744f
--- /dev/null
+++ b/hr_payroll_overtime/__init__.py
@@ -0,0 +1 @@
+from . import models
diff --git a/hr_payroll_overtime/__manifest__.py b/hr_payroll_overtime/__manifest__.py
new file mode 100644
index 00000000..98f43fc3
--- /dev/null
+++ b/hr_payroll_overtime/__manifest__.py
@@ -0,0 +1,22 @@
+{
+    'name': 'Payroll Overtime',
+    'description': 'Provide mechanisms to calculate overtime.',
+    'version': '15.0.1.0.0',
+    'website': 'https://hibou.io/',
+    'author': 'Hibou Corp. <hello@hibou.io>',
+    'license': 'AGPL-3',
+    'category': 'Human Resources',
+    'data': [
+        'security/ir.model.access.csv',
+        'data/overtime_data.xml',
+        'views/hr_contract_views.xml',
+        'views/hr_payslip_views.xml',
+        'views/hr_work_entry_views.xml',
+        'views/resource_calendar_views.xml',
+    ],
+    'depends': [
+        'hr_payroll_hibou',
+        'hr_work_entry',
+        'hr_work_entry_contract_enterprise',  # only for menu!
+    ],
+}
diff --git a/hr_payroll_overtime/data/overtime_data.xml b/hr_payroll_overtime/data/overtime_data.xml
new file mode 100644
index 00000000..9316f1ab
--- /dev/null
+++ b/hr_payroll_overtime/data/overtime_data.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+
+    <data noupdate="1">
+        <record id="work_entry_overtime_type" model="hr.work.entry.overtime.type">
+            <field name="name">Default Rules</field>
+            <field name="hours_per_week">40.0</field>
+            <field name="multiplier">1.5</field>
+        </record>
+    </data>
+
+</odoo>
\ No newline at end of file
diff --git a/hr_payroll_overtime/models/__init__.py b/hr_payroll_overtime/models/__init__.py
new file mode 100644
index 00000000..43cd2c4a
--- /dev/null
+++ b/hr_payroll_overtime/models/__init__.py
@@ -0,0 +1,4 @@
+from . import hr_contract
+from . import hr_payslip
+from . import hr_work_entry
+from . import resource_calendar
diff --git a/hr_payroll_overtime/models/hr_contract.py b/hr_payroll_overtime/models/hr_contract.py
new file mode 100644
index 00000000..e5847963
--- /dev/null
+++ b/hr_payroll_overtime/models/hr_contract.py
@@ -0,0 +1,8 @@
+from odoo import fields, models
+
+
+class HrContract(models.Model):
+    _inherit = 'hr.contract'
+
+    is_overtime_exempt = fields.Boolean(string='Overtime Exempt',
+                                        help='e.g. Agriculture or farm work exempt under the US FLSA.')
diff --git a/hr_payroll_overtime/models/hr_payslip.py b/hr_payroll_overtime/models/hr_payslip.py
new file mode 100644
index 00000000..e8bcd12e
--- /dev/null
+++ b/hr_payroll_overtime/models/hr_payslip.py
@@ -0,0 +1,174 @@
+from collections import defaultdict
+from odoo import api, fields, models
+from odoo.exceptions import UserError
+
+
+class HRPayslip(models.Model):
+    _inherit = 'hr.payslip'
+
+    def _get_worked_day_lines_values(self, domain=None):
+        worked_day_lines_values = super()._get_worked_day_lines_values(domain=domain)
+        return self._process_worked_day_lines_values(worked_day_lines_values, domaian=domain)
+
+    def _process_worked_day_lines_values(self, worked_day_lines_values, domaian=None):
+        if not self.state in ('draft', 'verify'):
+            return worked_day_lines_values
+
+        worked_day_lines_values = self._filter_worked_day_lines_values(worked_day_lines_values)
+        work_data = self._pre_aggregate_work_data()
+        work_data = self._post_aggregate_work_data(work_data)
+        processed_data = self._aggregate_overtime(work_data)
+        worked_day_lines_values += [{
+            'number_of_days': data[0],
+            'number_of_hours': data[1],
+            'rate': data[2],
+            'contract_id': self.contract_id.id,
+            'work_entry_type_id': work_type.id,
+        } for work_type, data in processed_data.items()]
+        return worked_day_lines_values
+
+    def _filter_worked_day_lines_values(self, worked_day_lines_values):
+        # e.g. maybe you want to remove the stock 'WORK100' lines
+        # returns new worked_day_lines_values
+        return worked_day_lines_values
+
+    def _pre_aggregate_work_data(self):
+        # returns dict(iso_date: list(tuple(hr.work.entry.type(), hours, original_record))
+        return defaultdict(list)
+
+    def _post_aggregate_work_data(self, work_data):
+        # takes pre_aggregate data format and converts it.
+        # this is to simplify algorithm and guarantee ordered by iso_date semantics
+        # work_data: dict(iso_date: list(tuple(hr.work.entry.type(), hours, original_record))
+        # returns: list(tuple(iso_date, list(tuple(hr.work.entry.type(), hours, original_record))
+        return [(iso_date, work_data[iso_date]) for iso_date in sorted(work_data.keys())]
+
+    def _aggregate_overtime(self, work_data, day_week_start=None):
+        """
+
+        :param work_data: list(tuple(iso_date, list(tuple(hr.work.entry.type(), hours, original_record))
+        :param day_week_start: day of the week to start (otherwise employee's resource calendar start day of week)
+        :return: dict(hr.work.entry.type(): list(days_worked, hours_worked, rate))
+        """
+        if not day_week_start:
+            if self.employee_id.resource_calendar_id.day_week_start:
+                day_week_start = self.employee_id.resource_calendar_id.day_week_start
+            else:
+                day_week_start = '1'
+        day_week_start = int(day_week_start)
+        if day_week_start < 1 or day_week_start > 7:
+            day_week_start = 1
+
+        def _adjust_week(isodate):
+            if isodate[2] < day_week_start:
+                return (isodate[0], isodate[1] + 1, isodate[2])
+            return isodate
+
+        result = defaultdict(lambda: [0.0, 0.0, 1.0])
+        day_hours = defaultdict(float)
+        week_hours = defaultdict(float)
+        iso_days = set()
+        try:
+            for iso_date, entries in work_data:
+                iso_date = _adjust_week(iso_date)
+                for work_type, hours, _ in entries:
+                    self._aggregate_overtime_add_work_type_hours(work_type, hours, iso_date, result, iso_days, day_hours, week_hours)
+        except RecursionError:
+            raise UserError('RecursionError raised.  Ensure you have not overtime loops, you should have an '
+                            'end work type that does not have any "overtime" version, and would be considered '
+                            'the "highest overtime" work type and rate.')
+
+        return result
+
+    def _aggregate_overtime_add_work_type_hours(self, work_type, hours, iso_date, working_aggregation, iso_days, day_hours, week_hours):
+        """
+        :param work_type: work type of hours being added
+        :param hours: hours being added
+        :param iso_date: date hours were worked
+        :param working_aggregation: dict of work type hours as they are processed
+        :param iso_days: set of iso days already seen
+        :param day_hours: hours worked on iso dates already processed
+        :param week_hours: hours worked on iso week already processed
+        :return:
+        """
+        override = work_type.override_for_iso_date(iso_date)
+        if override:
+            new_work_type = override.work_type_id
+            multiplier = override.multiplier
+            if work_type == new_work_type:
+                # trivial infinite recursion from override
+                raise UserError('Work type "%s" (id %s) must not have itself as its override work type. '
+                                'This occurred due to an override line "%s".' % (
+                                    work_type.name, work_type.id, override.name))
+            # update the work_type on this step.
+            work_type = new_work_type
+            working_aggregation[work_type][2] = multiplier
+
+        week = iso_date[1]
+        if not self.contract_id.is_overtime_exempt and work_type.overtime_work_type_id and work_type.overtime_type_id:
+            ot_h_w = work_type.overtime_type_id.hours_per_week
+            ot_h_d = work_type.overtime_type_id.hours_per_day
+
+            regular_hours = hours
+            # adjust the hours based on overtime conditions
+            if ot_h_d and (day_hours[iso_date] + hours) > ot_h_d:
+                # daily overtime in effect
+                remaining_hours = max(ot_h_d - day_hours[iso_date], 0.0)
+                regular_hours = min(remaining_hours, hours)
+            elif ot_h_w:
+                # not daily, but weekly limits....
+                remaining_hours = max(ot_h_w - week_hours[week], 0.0)
+                regular_hours = min(remaining_hours, hours)
+            ot_hours = hours - regular_hours
+            if regular_hours:
+                if iso_date not in iso_days:
+                    iso_days.add(iso_date)
+                    working_aggregation[work_type][0] += 1.0
+                working_aggregation[work_type][1] += regular_hours
+                day_hours[iso_date] += regular_hours
+                week_hours[week] += regular_hours
+            if ot_hours:
+                overtime_work_type = work_type.overtime_work_type_id
+                multiplier = work_type.overtime_type_id.multiplier
+                override = work_type.overtime_type_id.override_for_iso_date(iso_date)
+                if work_type == overtime_work_type:
+                    # trivial infinite recursion
+                    raise UserError('Work type "%s" (id %s) must not have itself as its next overtime type.' % (work_type.name, work_type.id))
+                if override:
+                    overtime_work_type = override.work_type_id
+                    multiplier = override.multiplier
+                    if work_type == overtime_work_type:
+                        # trivial infinite recursion from override
+                        raise UserError('Work type "%s" (id %s) must not have itself as its next overtime type. '
+                                        'This occurred due to an override "%s" from overtime rules "%s".' % (
+                            work_type.name, work_type.id, override.name, work_type.overtime_type_id.name))
+                # we need to save this because it won't be set once it reenter, we won't know what the original
+                # overtime multiplier was
+                working_aggregation[overtime_work_type][2] = multiplier
+                self._aggregate_overtime_add_work_type_hours(overtime_work_type, ot_hours, iso_date,
+                                                             working_aggregation, iso_days, day_hours, week_hours)
+        else:
+            # No overtime, just needs added to set
+            if iso_date not in iso_days:
+                iso_days.add(iso_date)
+                working_aggregation[work_type][0] += 1.0
+            working_aggregation[work_type][1] += hours
+            day_hours[iso_date] += hours
+            week_hours[week] += hours
+
+
+class HrPayslipWorkedDays(models.Model):
+    _inherit = 'hr.payslip.worked_days'
+
+    rate = fields.Float(string='Rate', default=1.0)
+
+    @api.depends('is_paid', 'number_of_hours', 'payslip_id', 'payslip_id.normal_wage', 'payslip_id.sum_worked_hours', 'rate')
+    def _compute_amount(self):
+        for worked_days in self:
+            if not worked_days.contract_id:
+                worked_days.amount = 0
+                continue
+            if worked_days.payslip_id.wage_type == "hourly":
+                worked_days.amount = worked_days.payslip_id.contract_id._get_contract_wage(work_type=worked_days.work_entry_type_id) * worked_days.number_of_hours * worked_days.rate if worked_days.is_paid else 0
+            else:
+                worked_days.amount = worked_days.payslip_id.normal_wage * worked_days.number_of_hours / (worked_days.payslip_id.sum_worked_hours or 1) if worked_days.is_paid else 0
diff --git a/hr_payroll_overtime/models/hr_work_entry.py b/hr_payroll_overtime/models/hr_work_entry.py
new file mode 100644
index 00000000..f607fd32
--- /dev/null
+++ b/hr_payroll_overtime/models/hr_work_entry.py
@@ -0,0 +1,79 @@
+from odoo import api, fields, models
+from odoo.exceptions import ValidationError
+
+from .resource_calendar import WEEKDAY_SELECTION
+
+
+class WorkEntryOverride(models.AbstractModel):
+    _name = 'hr.work.entry.type.override.abstract'
+    _order = 'date desc, day_of_week'
+
+    name = fields.Char(string='Description')
+    work_type_id = fields.Many2one('hr.work.entry.type', string='Override Work Type', required=True,
+                                   help='Distinct Work Type for when this applies.')
+    multiplier = fields.Float(string='Multiplier',
+                              help='Rate for override. E.g. maybe you have "Sunday Pay" at 2.0x')
+    day_of_week = fields.Selection(WEEKDAY_SELECTION, string='Day of Week')
+    date = fields.Date(string='Date')
+
+    @api.constrains('day_of_week', 'date')
+    def _constrain_days(self):
+        for override in self:
+            if override.day_of_week and override.date:
+                raise ValidationError('An override should only have a Date OR Day of Week.')
+
+    def iso_date_applies(self, iso_date):
+        for override in self:
+            if override.date and override.date.isocalendar() == iso_date:
+                return override
+            if int(override.day_of_week) == iso_date[2]:
+                return override
+
+
+class HRWorkEntryType(models.Model):
+    _inherit = 'hr.work.entry.type'
+
+    overtime_work_type_id = fields.Many2one('hr.work.entry.type', string='Overtime Work Type')
+    overtime_type_id = fields.Many2one('hr.work.entry.overtime.type', string='Overtime Rules')
+    override_ids = fields.One2many('hr.work.entry.type.override', 'original_type_id', string='Overrides',
+                                   help='Override work entry type on payslip.')
+
+    def override_for_iso_date(self, iso_date):
+        return self.override_ids.iso_date_applies(iso_date)
+
+
+class HRWorkEntryTypeOverride(models.Model):
+    _name = 'hr.work.entry.type.override'
+    _inherit = 'hr.work.entry.type.override.abstract'
+    _description = 'Work Type Override'
+
+    original_type_id = fields.Many2one('hr.work.entry.type',
+                                       string='Work Entry Type')
+
+
+class HRWorkEntryOvertime(models.Model):
+    _name = 'hr.work.entry.overtime.type'
+    _description = 'Overtime Rules'
+
+    name = fields.Char(string='Name')
+    hours_per_day = fields.Float(string='Hours/Day',
+                                 help='Number of hours worked in a single day to trigger overtime.')
+    hours_per_week = fields.Float(string='Hours/Week',
+                                  help='Number of hours worked in a week to trigger overtime.')
+    multiplier = fields.Float(string='Multiplier',
+                              help='Rate for when overtime is reached.')
+    override_ids = fields.One2many('hr.work.entry.overtime.type.override', 'overtime_type_id',
+                                   string='Overrides',
+                                   help='Override lines with a Date will be considered before Day of Week.')
+
+    def override_for_iso_date(self, iso_date):
+        return self.override_ids.iso_date_applies(iso_date)
+
+
+class HRWorkEntryOvertimeOverride(models.Model):
+    _name = 'hr.work.entry.overtime.type.override'
+    _inherit = 'hr.work.entry.type.override.abstract'
+    _description = 'Overtime Rule Override'
+
+    overtime_type_id = fields.Many2one('hr.work.entry.overtime.type',
+                                       string='Overtime Rules')
diff --git a/hr_payroll_overtime/models/resource_calendar.py b/hr_payroll_overtime/models/resource_calendar.py
new file mode 100644
index 00000000..6d63a103
--- /dev/null
+++ b/hr_payroll_overtime/models/resource_calendar.py
@@ -0,0 +1,18 @@
+from odoo import fields, models
+
+
+WEEKDAY_SELECTION = [
+    ('1', 'Monday'),
+    ('2', 'Tuesday'),
+    ('3', 'Wednesday'),
+    ('4', 'Thursday'),
+    ('5', 'Friday'),
+    ('6', 'Saturday'),
+    ('7', 'Sunday'),
+]
+
+
+class ResourceCalendar(models.Model):
+    _inherit = 'resource.calendar'
+
+    day_week_start = fields.Selection(WEEKDAY_SELECTION, string='Day Week Starts', required=True, default='1')
diff --git a/hr_payroll_overtime/security/ir.model.access.csv b/hr_payroll_overtime/security/ir.model.access.csv
new file mode 100644
index 00000000..0b0223eb
--- /dev/null
+++ b/hr_payroll_overtime/security/ir.model.access.csv
@@ -0,0 +1,7 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_hr_work_entry_overtime_type,access_hr_work_entry_overtime_type,model_hr_work_entry_overtime_type,base.group_user,1,0,0,0
+manage_hr_work_entry_overtime_type,manage_hr_work_entry_overtime_type,model_hr_work_entry_overtime_type,hr_payroll.group_hr_payroll_manager,1,1,1,1
+access_hr_work_entry_overtime_type_override,access_hr_work_entry_overtime_type_override,model_hr_work_entry_overtime_type_override,base.group_user,1,0,0,0
+manage_hr_work_entry_overtime_type_override,manage_hr_work_entry_overtime_type_override,model_hr_work_entry_overtime_type_override,hr_payroll.group_hr_payroll_manager,1,1,1,1
+access_hr_work_entry_type_override,access_hr_work_entry_type_override,model_hr_work_entry_type_override,base.group_user,1,0,0,0
+manage_hr_work_entry_type_override,manage_hr_work_entry_type_override,model_hr_work_entry_type_override,hr_payroll.group_hr_payroll_manager,1,1,1,1
diff --git a/hr_payroll_overtime/tests/__init__.py b/hr_payroll_overtime/tests/__init__.py
new file mode 100644
index 00000000..304ffd07
--- /dev/null
+++ b/hr_payroll_overtime/tests/__init__.py
@@ -0,0 +1 @@
+from . import test_overtime
diff --git a/hr_payroll_overtime/tests/test_overtime.py b/hr_payroll_overtime/tests/test_overtime.py
new file mode 100644
index 00000000..bdb60347
--- /dev/null
+++ b/hr_payroll_overtime/tests/test_overtime.py
@@ -0,0 +1,527 @@
+from datetime import date
+
+from odoo.tests import common
+from odoo.exceptions import UserError, ValidationError
+
+
+class TestOvertime(common.TransactionCase):
+
+    def setUp(self):
+        super().setUp()
+        self.overtime_rules = self.env['hr.work.entry.overtime.type'].create({
+            'name': 'Test',
+            'hours_per_week': 40.0,
+            'multiplier': 1.5,
+        })
+        self.work_type_overtime = self.env['hr.work.entry.type'].create({
+            'name': 'Test Overtime',
+            'code': 'TEST_OT'
+        })
+        self.work_type = self.env['hr.work.entry.type'].create({
+            'name': 'Test',
+            'code': 'TEST',
+            'overtime_type_id': self.overtime_rules.id,
+            'overtime_work_type_id': self.work_type_overtime.id,
+        })
+        self.employee = self.env.ref('hr.employee_hne')
+        self.contract = self.employee.contract_ids.create({
+            'name': 'testing contract',
+            'employee_id': self.employee.id,
+            'date_start': '2020-01-01',
+            'wage': 2000.0,
+        })
+        self.payslip = self.env['hr.payslip'].create({
+            'name': 'test slip',
+            'employee_id': self.employee.id,
+            'contract_id': self.contract.id,
+            'date_from': '2020-06-11',
+            'date_to': '2020-06-15',
+        })
+
+    def test_02_overtime_aggregation(self):
+        # 38 hours in 1 week
+        work_data = [
+            ((2020, 24, 1), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 4.0, None),
+            ]),
+            ((2020, 24, 2), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 3), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 4), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertTrue(self.work_type_overtime not in result_data)
+        self.assertEqual(result_data[self.work_type][0], 4)
+        self.assertEqual(result_data[self.work_type][1], 38.0)
+
+        # 48 hours in 1 week
+        work_data += [
+            ((2020, 24, 5), [
+                (self.work_type, 10.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 5)
+        self.assertEqual(result_data[self.work_type][1], 40.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 8.0)
+
+        # 52 hours in 1 week
+        work_data += [
+            ((2020, 24, 6), [
+                (self.work_type, 4.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 5)
+        self.assertEqual(result_data[self.work_type][1], 40.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 1)
+        self.assertEqual(result_data[self.work_type_overtime][1], 12.0)
+
+        # reset and make two weeks
+        # 38 hours in 1 week x 2
+        input_work_data = [
+            ((2020, 24, 1), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 4.0, None),
+            ]),
+            ((2020, 24, 2), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 3), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 4), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+        work_data = []
+        for data in input_work_data:
+            work_data.append(data)
+            work_data.append(((data[0][0], data[0][1]+1, data[0][2]), data[1]))
+
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertTrue(self.work_type_overtime not in result_data)
+        self.assertEqual(result_data[self.work_type][0], 8)
+        self.assertEqual(result_data[self.work_type][1], 76.0)
+
+        # 48 hours in 1 week, 38 hours in 1 week
+        work_data += [
+            ((2020, 24, 5), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 9)
+        self.assertEqual(result_data[self.work_type][1], 78.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 8.0)
+
+        # 52 hours in 1 week, 38 hours in 1 week
+        work_data += [
+            ((2020, 24, 6), [
+                (self.work_type, 4.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 9)
+        self.assertEqual(result_data[self.work_type][1], 78.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 1)
+        self.assertEqual(result_data[self.work_type_overtime][1], 12.0)
+
+    def test_03_overtime_aggregation_week_start(self):
+        self.employee.resource_calendar_id.day_week_start = '7'
+        self.test_02_overtime_aggregation()
+
+    def test_10_overtime_aggregation_daily(self):
+        self.overtime_rules.hours_per_day = 8.0
+        self.overtime_rules.multiplier = 1.5
+        # 38 hours in 1 week
+        work_data = [
+            ((2020, 24, 1), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 4.0, None),
+            ]),
+            ((2020, 24, 2), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 3), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 4), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 4)
+        self.assertEqual(result_data[self.work_type][1], 32.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 6.0)
+
+        # 48 hours in 1 week
+        work_data += [
+            ((2020, 24, 5), [
+                (self.work_type, 10.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 5)
+        self.assertEqual(result_data[self.work_type][1], 40.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 8.0)
+
+        # 52 hours in 1 week
+        work_data += [
+            ((2020, 24, 6), [
+                (self.work_type, 4.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 5)
+        self.assertEqual(result_data[self.work_type][1], 40.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 1)
+        self.assertEqual(result_data[self.work_type_overtime][1], 12.0)
+
+        # reset and make two weeks
+        # 38 hours in 1 week x 2
+        input_work_data = [
+            ((2020, 24, 1), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 4.0, None),
+            ]),
+            ((2020, 24, 2), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 3), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 4), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+        work_data = []
+        for data in input_work_data:
+            work_data.append(data)
+            work_data.append(((data[0][0], data[0][1]+1, data[0][2]), data[1]))
+
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type][0], 8)
+        self.assertEqual(result_data[self.work_type][1], 64.0)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 12.0)
+
+        # 48 hours in 1 week, 38 hours in 1 week
+        work_data += [
+            ((2020, 24, 5), [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 9)
+        self.assertEqual(result_data[self.work_type][1], 70.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 16.0)
+
+        # 52 hours in 1 week, 38 hours in 1 week
+        work_data += [
+            ((2020, 24, 6), [
+                (self.work_type, 4.0, None),
+            ]),
+        ]
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 9)
+        self.assertEqual(result_data[self.work_type][1], 70.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 1)
+        self.assertEqual(result_data[self.work_type_overtime][1], 20.0)
+
+    def test_11_overtime_aggregation_daily_week_start(self):
+        self.employee.resource_calendar_id.day_week_start = '7'
+        self.test_10_overtime_aggregation_daily()
+
+    def test_12_recursive_daily(self):
+        # recursive will use a second overtime
+        self.work_type_overtime2 = self.env['hr.work.entry.type'].create({
+            'name': 'Test Overtime 2',
+            'code': 'TEST_OT2'
+        })
+        self.overtime_rules2 = self.env['hr.work.entry.overtime.type'].create({
+            'name': 'Test2',
+            'hours_per_week': 999.0,
+            'hours_per_day': 12.0,
+            'multiplier': 2.0,
+        })
+        self.overtime_rules.hours_per_day = 8.0
+        self.overtime_rules.multiplier = 1.5
+        self.work_type_overtime.overtime_type_id = self.overtime_rules2
+        self.work_type_overtime.overtime_work_type_id = self.work_type_overtime2
+
+        work_data = [
+            ((2020, 24, 1), [
+                # regular day
+                (self.work_type, 4.0, None),
+                (self.work_type, 4.0, None),
+            ]),
+            ((2020, 24, 2), [
+                # 2hr overtime
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 3), [
+                # 4hr overtime
+                (self.work_type, 6.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+            ((2020, 24, 4), [
+                # 4hr overtime
+                # 2hr overtime2
+                (self.work_type, 6.0, None),
+                (self.work_type, 8.0, None),
+            ]),
+        ]
+
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 4)
+        self.assertEqual(result_data[self.work_type][1], 32.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 10.0)
+        self.assertTrue(self.work_type_overtime2 in result_data)
+        self.assertEqual(result_data[self.work_type_overtime2][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime2][1], 2.0)
+
+    def test_13_recursive_infinite_trivial(self):
+        # recursive should will use a second overtime, but not this time!
+        self.overtime_rules.hours_per_day = 8.0
+        self.overtime_rules.multiplier = 1.5
+        self.work_type.overtime_type_id = self.overtime_rules
+        # overtime goes to itself
+        self.work_type.overtime_work_type_id = self.work_type
+
+        work_data = [
+            ((2020, 24, 2), [
+                # 2hr overtime
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+
+        with self.assertRaises(UserError):
+            result_data = self.payslip._aggregate_overtime(work_data)
+
+    def test_14_recursive_infinite_loop(self):
+        # recursive will use a second overtime, but not this time!
+        self.overtime_rules.hours_per_day = 8.0
+        self.overtime_rules.multiplier = 1.5
+        self.work_type_overtime.overtime_type_id = self.overtime_rules
+        # overtime goes back to worktype
+        self.work_type_overtime.overtime_work_type_id = self.work_type
+
+        work_data = [
+            ((2020, 24, 2), [
+                # 2hr overtime
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+
+        with self.assertRaises(UserError):
+            result_data = self.payslip._aggregate_overtime(work_data)
+
+    def test_15_override_day_of_week(self):
+        iso_date = (2020, 24, 1)
+        self.overtime_rules.hours_per_day = 8.0
+        self.overtime_rules.multiplier = 1.5
+        work_data = [
+            (iso_date, [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 1)
+        self.assertEqual(result_data[self.work_type][1], 8.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
+        self.assertEqual(result_data[self.work_type_overtime][2], 1.5)
+
+
+        # Now lets make an override line
+        self.overtime_rules.write({
+            'override_ids': [(0, 0, {
+                'name': 'Day 1 Override',
+                'multiplier': 2.0,
+                'day_of_week': str(iso_date[2]),
+                'work_type_id': self.work_type_overtime.id,  # Note that this wouldn't be good in practice
+            })]
+        })
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 1)
+        self.assertEqual(result_data[self.work_type][1], 8.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
+        self.assertEqual(result_data[self.work_type_overtime][2], 2.0)  # rate 2x
+
+    def test_16_override_date(self):
+        iso_date = (2020, 24, 1)
+        self.overtime_rules.hours_per_day = 8.0
+        self.overtime_rules.multiplier = 1.5
+        work_data = [
+            (iso_date, [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 1)
+        self.assertEqual(result_data[self.work_type][1], 8.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
+        self.assertEqual(result_data[self.work_type_overtime][2], 1.5)
+
+        # Now lets make a specific date override
+        self.overtime_rules.write({
+            'override_ids': [(0, 0, {
+                'name': 'Day (2020, 24, 1) Override',
+                'multiplier': 3.0,
+                'date': date(2020, 6, 8),  # date.fromisocalendar(*iso_date),
+                'work_type_id': self.work_type_overtime.id,  # Note that this wouldn't be good in practice
+            })]
+        })
+        self.overtime_rules.flush()
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 1)
+        self.assertEqual(result_data[self.work_type][1], 8.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
+        self.assertEqual(result_data[self.work_type_overtime][2], 3.0)  # rate 3x
+
+    def test_17_override_config(self):
+        with self.assertRaises(ValidationError):
+            self.overtime_rules.write({
+                'override_ids': [(0, 0, {
+                    'name': 'Day (2020, 24, 1) Override',
+                    'multiplier': 3.0,
+                    # cannot have both date and day_of_week
+                    'date': date(2020, 6, 8),
+                    'day_of_week': '1',
+                    'work_type_id': self.work_type_overtime.id,  # Note that this wouldn't be good in practice
+                })]
+            })
+
+    def test_18_override_day_of_week_on_work_type(self):
+        iso_date = (2020, 24, 1)
+        iso_date2 = (2020, 24, 2)
+
+        work_data = [
+            (iso_date, [
+                (self.work_type, 4.0, None),
+            ]),
+            (iso_date2, [
+                (self.work_type, 4.0, None),
+            ]),
+        ]
+
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 2)
+        self.assertEqual(result_data[self.work_type][1], 8.0)
+
+        # Now lets make an override line
+        test_multiplier = 3.0
+        self.work_type.write({
+            'override_ids': [(0, 0, {
+                'name': 'Day 2 Override',
+                'multiplier': test_multiplier,
+                'day_of_week': str(iso_date[2]),
+                'work_type_id': self.work_type_overtime.id,  # Note that this wouldn't be good in practice
+            })]
+        })
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 1)
+        self.assertEqual(result_data[self.work_type][1], 4.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 1)
+        self.assertEqual(result_data[self.work_type_overtime][1], 4.0)
+        self.assertEqual(result_data[self.work_type_overtime][2], test_multiplier)
+
+    def test_19_overtime_exempt(self):
+        iso_date = (2020, 24, 1)
+        self.overtime_rules.hours_per_day = 8.0
+        work_data = [
+            (iso_date, [
+                (self.work_type, 4.0, None),
+                (self.work_type, 6.0, None),
+            ]),
+        ]
+
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 1)
+        self.assertEqual(result_data[self.work_type][1], 8.0)
+        self.assertTrue(self.work_type_overtime in result_data)
+        self.assertEqual(result_data[self.work_type_overtime][0], 0)
+        self.assertEqual(result_data[self.work_type_overtime][1], 2.0)
+        self.assertEqual(result_data[self.work_type_overtime][2], 1.5)
+
+        self.payslip.contract_id.is_overtime_exempt = True
+        self.assertTrue(self.payslip.contract_id)
+        self.assertTrue(self.payslip.contract_id.is_overtime_exempt)
+        result_data = self.payslip._aggregate_overtime(work_data)
+        self.assertTrue(self.work_type in result_data)
+        self.assertEqual(result_data[self.work_type][0], 1)
+        self.assertEqual(result_data[self.work_type][1], 10.0)
+        self.assertTrue(self.work_type_overtime not in result_data)
diff --git a/hr_payroll_overtime/views/hr_contract_views.xml b/hr_payroll_overtime/views/hr_contract_views.xml
new file mode 100644
index 00000000..0e6b9a61
--- /dev/null
+++ b/hr_payroll_overtime/views/hr_contract_views.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<odoo>
+
+    <record id="hr_contract_form_inherit" model="ir.ui.view">
+        <field name="name">hr.contract.form.inherit</field>
+        <field name="model">hr.contract</field>
+        <field name="inherit_id" ref="hr_contract.hr_contract_view_form"/>
+        <field name="arch" type="xml">
+            <xpath expr="//field[@name='wage_type']" position="after">
+                <field name="is_overtime_exempt" />
+            </xpath>
+        </field>
+    </record>
+
+</odoo>
diff --git a/hr_payroll_overtime/views/hr_payslip_views.xml b/hr_payroll_overtime/views/hr_payslip_views.xml
new file mode 100644
index 00000000..7b5a2601
--- /dev/null
+++ b/hr_payroll_overtime/views/hr_payslip_views.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+
+    <!-- Payslip Form -->
+    <record id="view_hr_payslip_form_inherit" model="ir.ui.view">
+        <field name="name">hr.payslip.form.inherit</field>
+        <field name="model">hr.payslip</field>
+        <field name="inherit_id" ref="hr_payroll.view_hr_payslip_form"/>
+        <field name="arch" type="xml">
+            <xpath expr="//field[@name='worked_days_line_ids']/tree/field[@name='number_of_hours']" position="after">
+                <field name="rate"/>
+            </xpath>
+            <xpath expr="//field[@name='worked_days_line_ids']/form//field[@name='number_of_hours']" position="after">
+                <field name="rate"/>
+            </xpath>
+        </field>
+    </record>
+
+</odoo>
diff --git a/hr_payroll_overtime/views/hr_work_entry_views.xml b/hr_payroll_overtime/views/hr_work_entry_views.xml
new file mode 100644
index 00000000..43ffd02a
--- /dev/null
+++ b/hr_payroll_overtime/views/hr_work_entry_views.xml
@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+
+    <!-- Work Entry Type -->
+    <record id="hr_work_entry_type_view_form_inherit" model="ir.ui.view">
+        <field name="name">hr.work.entry.type.form.inherit</field>
+        <field name="model">hr.work.entry.type</field>
+        <field name="inherit_id" ref="hr_work_entry.hr_work_entry_type_view_form"/>
+        <field name="arch" type="xml">
+            <xpath expr="//group[@name='main_group']" position="after">
+                <group name="overtime_group">
+                    <field name="overtime_work_type_id"
+                           domain="[('id', '!=', id)]"
+                           attrs="{'required': [('overtime_type_id', '!=', False)]}" />
+                    <field name="overtime_type_id"
+                           domain="[('id', '!=', id)]"
+                           attrs="{'required': [('overtime_work_type_id', '!=', False)]}" />
+
+                    <field name="override_ids" nolabel="1" colspan="2">
+                        <tree editable="top">
+                            <field name="work_type_id"/>
+                            <field name="multiplier"/>
+                            <field name="date"/>
+                            <field name="day_of_week"/>
+                            <field name="name"/>
+                        </tree>
+                    </field>
+                </group>
+            </xpath>
+        </field>
+    </record>
+    
+    <!-- Work Entry Overtime Type -->
+    <record id="hr_work_entry_overtime_type_tree" model="ir.ui.view">
+        <field name="name">hr.work.entry.overtime.type.tree</field>
+        <field name="model">hr.work.entry.overtime.type</field>
+        <field name="arch" type="xml">
+            <tree string="Overtime Rules">
+                <field name="name"/>
+                <field name="hours_per_day"/>
+                <field name="hours_per_week"/>
+                <field name="multiplier"/>
+            </tree>
+        </field>
+    </record>
+
+    <record id="hr_work_entry_overtime_type_form" model="ir.ui.view">
+        <field name="name">hr.work.entry.overtime.type.form</field>
+        <field name="model">hr.work.entry.overtime.type</field>
+        <field name="arch" type="xml">
+            <form string="Overtime Rules">
+                <group>
+                    <group>
+                        <field name="name"/>
+                        <field name="multiplier"/>
+                    </group>
+                    <group>
+                        <field name="hours_per_day"/>
+                        <field name="hours_per_week"/>
+                    </group>
+                </group>
+                <group name="overrides" string="Overrides">
+                    <field name="override_ids" nolabel="1">
+                        <tree editable="top">
+                            <field name="work_type_id"/>
+                            <field name="multiplier"/>
+                            <field name="date"/>
+                            <field name="day_of_week"/>
+                            <field name="name"/>
+                        </tree>
+                    </field>
+                </group>
+            </form>
+        </field>
+    </record>
+
+    <record id="hr_work_entry_overtime_type_search" model="ir.ui.view">
+        <field name="name">hr.work.entry.overtime.type.search</field>
+        <field name="model">hr.work.entry.overtime.type</field>
+        <field name="arch" type="xml">
+            <search string="Overtime Rules Search">
+                <field name="name"/>
+            </search>
+        </field>
+    </record>
+
+    <record id="hr_work_entry_overtime_type_action_main" model="ir.actions.act_window">
+        <field name="name">Overtime Rules</field>
+        <field name="res_model">hr.work.entry.overtime.type</field>
+        <field name="view_mode">tree,form</field>
+        <field name="help" type="html">
+            <p>
+                No Overtime Rules
+            </p>
+        </field>
+    </record>
+
+    <menuitem id="hr_work_entry_overtime_type_menu_main" name="Overtime Rules"
+              action="hr_work_entry_overtime_type_action_main"
+              sequence="11" parent="hr_work_entry_contract_enterprise.menu_hr_work_entry_type_view"/>
+
+</odoo>
\ No newline at end of file
diff --git a/hr_payroll_overtime/views/resource_calendar_views.xml b/hr_payroll_overtime/views/resource_calendar_views.xml
new file mode 100644
index 00000000..444dcc16
--- /dev/null
+++ b/hr_payroll_overtime/views/resource_calendar_views.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<odoo>
+
+    <record id="resource_calendar_form_inherit" model="ir.ui.view">
+        <field name="name">resource.calendar.form.inherit</field>
+        <field name="model">resource.calendar</field>
+        <field name="inherit_id" ref="resource.resource_calendar_form"/>
+        <field name="arch" type="xml">
+            <xpath expr="//field[@name='tz']" position="after">
+                <field name="day_week_start"/>
+            </xpath>
+        </field>
+    </record>
+
+</odoo>
\ No newline at end of file