diff --git a/chores/core.py b/chores/core.py
new file mode 100644
index 00000000..444eabae
--- /dev/null
+++ b/chores/core.py
@@ -0,0 +1,418 @@
+import logging
+from datetime import datetime, timedelta, timezone
+from functools import total_ordering
+
+import humanize
+from croniter import croniter
+from dateutil.tz import tzlocal
+from django.core.mail import EmailMessage
+
+from .messages import VolunteeringReminderNotification
+from .models import Chore, ChoreNotification
+
+logger = logging.getLogger(__name__)
+
+HUMAN_DATETIME_STRING = "%H:%M:%S %d/%m/%Y"
+local_timezone = tzlocal()
+
+
+class BaseNudge(object):
+    """Base class for all nudge types with common functionality."""
+
+    def __init__(self, event):
+        self.event = event
+
+    def get_string_key(self):
+        """Generate a unique string key for this nudge."""
+        event_key = self.event.get_object_key()
+        return "{0}-{1}-{2}".format(
+            self.nudge_key, event_key["chore_id"], event_key["ts"]
+        )
+
+    def send(self):
+        """Send the nudge - to be implemented by subclasses."""
+        raise NotImplementedError("Subclasses must implement send()")
+
+    def should_send(self, message_key):
+        """Check if a message with this key should be sent (not already sent)."""
+        return not ChoreNotification.objects.filter(event_key=message_key).exists()
+
+    def record_send(self, message_key, user=None):
+        """Record that a message with this key has been sent."""
+        ChoreNotification.objects.create(
+            event_key=message_key,
+            chore=Chore.objects.get(id=self.event.get_object_key()["chore_id"]),
+            recipient_user=user if "volunteer" in message_key else None,
+            recipient_other=None
+            if "volunteer" in message_key
+            else "deelnemers@makerspaceleiden.nl",
+        )
+
+
+class EmailNudge(BaseNudge):
+    def __init__(self, event, nudge_key, destination, subject, body):
+        super().__init__(event)
+        self.nudge_key = nudge_key
+        self.destination = destination
+        self.subject = subject
+        self.body = body
+
+    def __str__(self):
+        return "Email nudge. Chore: {0}, to: {1}, subject: {2}".format(
+            self.event.chore.name, self.destination, self.subject
+        )
+
+    def send(self):
+        logger.info("Sending email nudge to: {0}".format(self.destination))
+        logger.debug("EmailNudge.send", self.destination)
+
+        if self.should_send(self.get_string_key()):
+            EmailMessage(
+                self.subject,
+                self.body,
+                to=[self.destination],
+                from_email="MakerSpace BOT <noc@makerspaceleiden.nl>",
+            ).send()
+            self.record_send(self.get_string_key())
+
+    # Honour the Message API (see messages.py)
+    def get_subject_for_email(self):
+        return self.subject
+
+    # Honour the Message API (see messages.py)
+    def get_email_text(self):
+        return self.body + "\n"
+
+
+class VolunteersReminderNudge(BaseNudge):
+    def __init__(self, event, params):
+        super().__init__(event)
+        self.volunteers = params.volunteers
+        self.nudge_key = "volunteer-reminder"
+
+    def __str__(self):
+        return "Volunteer reminder via Chat BOT: {0}".format(self.event.chore.name)
+
+    def send(self):
+        logger.debug("VolunteersReminderNudge.Send", len(self.volunteers))
+        logger.info(
+            "Sending volunteering reminder to: {0}".format(
+                ", ".join(["{0}".format(u.full_name) for u in self.volunteers])
+            )
+        )
+        for choreVolunteer in self.volunteers:
+            notification_key = self.get_string_key() + "-{0}".format(
+                choreVolunteer.user.id
+            )
+            if self.should_send(notification_key):
+                logger.debug(
+                    "aggregator.send_user_notification.{0}".format(choreVolunteer.user)
+                )
+                message = VolunteeringReminderNotification(
+                    choreVolunteer.user, self.event
+                )
+                EmailMessage(
+                    message.get_subject_for_email(),
+                    message.get_text(),
+                    to=[choreVolunteer.user.email],
+                    from_email="MakerSpace BOT <noc@makerspaceleiden.nl>",
+                ).send()
+                self.record_send(notification_key, choreVolunteer.user)
+
+
+class ChoreEventsLogic(object):
+    def __init__(self, chores):
+        self.chores = [build_chore_instance(chore) for chore in chores]
+
+    def get_events_from_to(self, ts_from, ts_to):
+        events = []
+        for chore in self.chores:
+            events.extend(chore.iter_events_from_to(ts_from, ts_to))
+
+        events.sort(key=lambda c: c.ts)
+        return events
+
+    def iter_events_with_reminders_from_to(self, ts_from, ts_to):
+        logger.debug("iter_events_with_reminders_from_to", ts_from, ts_to)
+        num_days_of_earliest_reminder = max(
+            [0] + [chore.get_num_days_of_earliest_reminder() for chore in self.chores]
+        )
+        for event in self.get_events_from_to(
+            ts_from, ts_to.add(num_days_of_earliest_reminder + 1, "days")
+        ):
+            logger.debug("get_events_from_to.event", event)
+            for reminder in event.chore.reminders:
+                logger.debug("event.chore.reminders", reminder)
+                reminder_time = calculate_reminder_time(event, reminder.when)
+                if ts_from <= reminder_time <= ts_to:
+                    yield event
+
+
+class ChoreEvent(object):
+    def __init__(self, chore, ts):
+        self.chore = chore
+        self.ts = ts
+
+    def get_object_key(self):
+        return {
+            "chore_id": self.chore.chore_id,
+            "ts": self.ts.as_int_timestamp(),
+        }
+
+    def for_json(self):
+        return {
+            "chore": self.chore.for_json(),
+            "when": {
+                "timestamp": self.ts.as_int_timestamp(),
+                "human_str": self.ts.human_str(),
+            },
+        }
+
+    def iter_nudges(self, params):
+        for reminder in self.chore.reminders:
+            for nudge in reminder.iter_nudges(self, params):
+                yield nudge
+
+
+class BasicChore(object):
+    def __init__(
+        self,
+        chore_id,
+        name,
+        description,
+        min_required_people,
+        events_generation,
+        reminders,
+    ):
+        self.chore_id = chore_id
+        self.name = name
+        self.description = description
+        self.min_required_people = min_required_people
+
+        self.events_generator = None
+        event_type = events_generation["event_type"]
+        data = dict(events_generation)
+        del data["event_type"]
+        if event_type == "recurrent":
+            self.events_generator = RecurrentEventGenerator(**data)
+        elif event_type == "single_occurrence":
+            self.events_generator = SingleOccurrenceEventGenerator(**data)
+
+        self.reminders = [
+            build_reminder(self.min_required_people, **reminder)
+            for reminder in reminders
+        ]
+
+    def iter_events_from_to(self, ts_from, ts_to):
+        """
+        Yield events generated by the events_generator between two timestamps.
+
+        Args:
+            ts_from (int): The start timestamp (inclusive).
+            ts_to (int): The end timestamp (inclusive).
+
+        Yields:
+            event: Each event generated by the events_generator within the given range.
+        """
+        if self.events_generator:
+            for event in self.events_generator.iter_events_from_to(
+                self, ts_from, ts_to
+            ):
+                yield event
+
+    def for_json(self):
+        return {
+            "chore_id": self.chore_id,
+            "name": self.name,
+            "description": self.description,
+            "min_required_people": self.min_required_people,
+        }
+
+    def get_num_days_of_earliest_reminder(self):
+        return max([0] + [reminder.when["days_before"] for reminder in self.reminders])
+
+
+class RecurrentEventGenerator(object):
+    def __init__(self, starting_time, crontab, take_one_every):
+        self.starting_time = Time.from_datetime(
+            datetime.strptime(starting_time, "%d/%m/%Y %H:%M")
+        )
+        self.crontab = crontab
+        self.take_one_every = take_one_every
+
+    def iter_events_from_to(self, aggregator, ts_from, ts_to):
+        for idx, ts in enumerate(Time.iter_crontab(self.crontab, self.starting_time)):
+            if ts > ts_to:
+                break
+            if ts >= ts_from and idx % self.take_one_every == 0:
+                yield ChoreEvent(aggregator, ts)
+
+
+class SingleOccurrenceEventGenerator(object):
+    def __init__(self, event_time):
+        self.event_time = Time.from_datetime(
+            datetime.strptime(event_time, "%d/%m/%Y %H:%M")
+        )
+
+    def iter_events_from_to(self, aggregator, ts_from, ts_to):
+        if ts_from <= self.event_time <= ts_to:
+            yield ChoreEvent(aggregator, self.event_time)
+
+
+ALL_CHORE_TYPES = [
+    BasicChore,
+]
+
+
+class MissingVolunteersReminder(object):
+    def __init__(self, min_required_people, when, nudges):
+        self.min_required_people = min_required_people
+        self.when = when
+        self.nudges = nudges
+
+    def iter_nudges(self, event, params):
+        reminder_time = calculate_reminder_time(event, self.when)
+        if params.now > reminder_time and len(params.volunteers) == 0:
+            for nudge in self.nudges:
+                if nudge["nudge_type"] == "email":
+                    yield self._build_email_nudge(event, nudge, params)
+                else:
+                    logger.warn("Unsupported nudge type", nudge["nudge_type"])
+
+    def _build_email_nudge(self, event, nudge, params):
+        template_data = {
+            "event_day": event.ts.strftime("%a %d/%m/%Y %H:%M"),
+            "chore_description": event.chore.description,
+            "num_volunteers_needed": self.min_required_people - len(params.volunteers),
+            "signup_url": params.urls.chores(),
+        }
+        return EmailNudge(
+            event=event,
+            nudge_key=nudge["nudge_key"],
+            destination=nudge["destination"],
+            subject=nudge["subject_template"].format(**template_data),
+            body=nudge["body_template"].format(**template_data),
+        )
+
+
+class VolunteersReminder(object):
+    def __init__(self, when):
+        self.when = when
+
+    def iter_nudges(self, event, params):
+        reminder_time = calculate_reminder_time(event, self.when)
+        if params.now > reminder_time:
+            yield VolunteersReminderNudge(event, params)
+
+
+def build_reminder(min_required_people, reminder_type, when, nudges=None):
+    logger.debug("build_reminder", reminder_type, when)
+    if reminder_type == "missing_volunteers":
+        return MissingVolunteersReminder(min_required_people, when, nudges)
+    if reminder_type == "volunteers_who_signed_up":
+        return VolunteersReminder(when)
+    raise Exception(f"Unknown reminder type {repr(reminder_type)}")
+
+
+def get_chore_type_class(chore):
+    for chore_class in ALL_CHORE_TYPES:
+        if chore_class.__name__ == chore.class_type:
+            return chore_class
+    raise Exception(f'Cannot find Python class for chore of type "{chore.class_type}"')
+
+
+def build_chore_instance(chore):
+    chore_class = get_chore_type_class(chore)
+    return chore_class(chore.id, chore.name, chore.description, **chore.configuration)
+
+
+def parse_hhmm(hhmm_str):
+    hh, mm = hhmm_str.split(":")
+    return int(hh), int(mm)
+
+
+def calculate_reminder_time(event, when):
+    logger.debug("calculate_reminder_time", event, when)
+    hh, mm = parse_hhmm(when["time"])
+    reminder_time = event.ts.add(-when["days_before"], "days").replace(
+        hour=hh, minute=mm
+    )
+    return reminder_time
+
+
+@total_ordering
+class Time(object):
+    # Internally represents time in UTC
+    # The internal instance of datetime object is naive, i.e. without timezone information
+
+    def __init__(self, dt):
+        self.dt = dt
+
+    def __repr__(self):
+        return f"<Time {self.human_str()}>"
+
+    def __eq__(self, other):
+        return self.dt == other.dt
+
+    def __ne__(self, other):
+        return self.dt != other.dt
+
+    def __lt__(self, other):
+        return self.dt < other.dt
+
+    def __hash__(self):
+        return hash(self.dt)
+
+    def as_int_timestamp(self):
+        return int(self.dt.replace(tzinfo=timezone.utc).timestamp())
+
+    def sorting_key(self):
+        return self.as_int_timestamp()
+
+    def replace(self, hour=None, minute=None):
+        return Time(self.dt.replace(hour=hour, minute=minute, second=0))
+
+    @classmethod
+    def from_timestamp(cls, ts):
+        return cls(datetime.utcfromtimestamp(ts))
+
+    @classmethod
+    def from_datetime(cls, dt):
+        return cls(dt)
+
+    def human_str(self):
+        return self.strftime(HUMAN_DATETIME_STRING)
+
+    def strftime(self, _format):
+        return (
+            self.dt.replace(tzinfo=timezone.utc)
+            .astimezone(local_timezone)
+            .strftime(_format)
+        )
+
+    def human_delta_from(self, ts_from):
+        delta = (self.dt - ts_from.dt).total_seconds()
+        return humanize.naturaldelta(delta) + " ago"
+
+    def delta_in_hours(self, ts_from):
+        return (self.dt - ts_from.dt).total_seconds() / 3600
+
+    def add(self, how_much, what):
+        if what in ("minute", "minutes"):
+            return Time(self.dt + timedelta(minutes=how_much))
+        if what in ("hour", "hours"):
+            return Time(self.dt + timedelta(hours=how_much))
+        if what in ("day", "days"):
+            return Time(self.dt + timedelta(days=how_much))
+
+    @classmethod
+    def iter_crontab(cls, crontab, starting_ts):
+        croniter_iterator = croniter(crontab, starting_ts.dt)
+        while True:
+            dt = (
+                croniter_iterator.get_next(datetime)
+                .replace(tzinfo=local_timezone)
+                .astimezone(timezone.utc)
+                .replace(tzinfo=None)
+            )
+            yield cls.from_datetime(dt)
diff --git a/chores/management/__init__.py b/chores/management/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/chores/management/commands/send_reminders.py b/chores/management/commands/send_reminders.py
new file mode 100644
index 00000000..a53df621
--- /dev/null
+++ b/chores/management/commands/send_reminders.py
@@ -0,0 +1,64 @@
+import logging
+from collections import namedtuple
+from datetime import datetime
+
+from django.core.management.base import BaseCommand
+
+from ...core import ChoreEventsLogic, Time
+from ...models import Chore, ChoreVolunteer
+
+logger = logging.getLogger(__name__)
+
+
+NudgesParams = namedtuple(
+    "NudgesParams", "volunteers now urls message_users_seen_no_later_than_days"
+)
+
+
+class Clock(object):
+    @staticmethod
+    def now():
+        return Time.from_datetime(datetime.utcnow())
+
+
+class Command(BaseCommand):
+    help = "Send reminders for chores"
+
+    def handle(self, *args, **kwargs):
+        chores = Chore.objects.all()
+        logger.debug("handle", len(chores))
+        now = Clock.now()
+
+        # Configuration lifted from aggregator
+        # TODO: Make these configurable
+        self.chores_warnings_check_window_in_hours = 2
+        self.chores_message_users_seen_no_later_than_days = 14
+
+        for event in ChoreEventsLogic(chores).iter_events_with_reminders_from_to(
+            now.add(-self.chores_warnings_check_window_in_hours, "hours"), now
+        ):
+            volunteers = ChoreVolunteer.objects.all().filter(chore=event.chore.chore_id)
+            logger.debug("send_reminders.handle.volunteers", len(volunteers))
+            params = NudgesParams(
+                volunteers,
+                now,
+                Urls(),
+                self.chores_message_users_seen_no_later_than_days,
+            )
+            for nudge in event.iter_nudges(params):
+                logger.info("Processing Chore nudge: {0}".format(nudge))
+                logger.debug("nudge.get_string_key", nudge.get_string_key())
+                nudge.send()
+
+        self.stdout.write("Sending notifications")
+
+
+class Urls(object):
+    def notification_settings(self):
+        return "https://mijn.makerspaceleiden.nl/notifications/settings"
+
+    def space_state(self):
+        return "https://mijn.makerspaceleiden.nl/space_state"
+
+    def chores(self):
+        return "https://mijn.makerspaceleiden.nl/chores/"
diff --git a/chores/messages.py b/chores/messages.py
new file mode 100644
index 00000000..fb540f6a
--- /dev/null
+++ b/chores/messages.py
@@ -0,0 +1,12 @@
+class VolunteeringReminderNotification(object):
+    def __init__(self, user, event):
+        self.user = user
+        self.event = event
+
+    def get_text(self):
+        chore_description = self.event.chore.description
+        chore_event_ts_human = self.event.ts.strftime("%a %d/%m/%Y %H:%M")
+        return f"{self.user.first_name}, here's a friendly reminder that you signed up for {chore_description} at {chore_event_ts_human}. Don't forget!"
+
+    def get_subject_for_email(self):
+        return "Volunteering reminder"
diff --git a/chores/migrations/0005_chorenotification.py b/chores/migrations/0005_chorenotification.py
new file mode 100644
index 00000000..3b0e28cc
--- /dev/null
+++ b/chores/migrations/0005_chorenotification.py
@@ -0,0 +1,53 @@
+# Generated by Django 4.2.21 on 2025-07-11 18:11
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("chores", "0004_chore_wiki_url_historicalchore_wiki_url"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="ChoreNotification",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("event_key", models.CharField(max_length=128, unique=True)),
+                (
+                    "recipient_other",
+                    models.EmailField(blank=True, max_length=254, null=True),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                (
+                    "chore",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="notifications",
+                        to="chores.chore",
+                    ),
+                ),
+                (
+                    "recipient_user",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="chore_notifications",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+    ]
diff --git a/chores/migrations/0006_alter_chore_configuration_and_more.py b/chores/migrations/0006_alter_chore_configuration_and_more.py
new file mode 100644
index 00000000..0087557e
--- /dev/null
+++ b/chores/migrations/0006_alter_chore_configuration_and_more.py
@@ -0,0 +1,24 @@
+# Generated by Django 4.2.21 on 2025-07-13 11:31
+
+from django.db import migrations, models
+
+import chores.models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("chores", "0005_chorenotification"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="chore",
+            name="configuration",
+            field=models.JSONField(validators=[chores.models.validate_json]),
+        ),
+        migrations.AlterField(
+            model_name="historicalchore",
+            name="configuration",
+            field=models.JSONField(validators=[chores.models.validate_json]),
+        ),
+    ]
diff --git a/chores/models.py b/chores/models.py
index fbb107d9..1ac71404 100644
--- a/chores/models.py
+++ b/chores/models.py
@@ -1,6 +1,5 @@
 import json
 
-import jsonfield
 from django.core import exceptions
 from django.db import models
 from simple_history.models import HistoricalRecords
@@ -20,7 +19,7 @@ class Chore(models.Model):
     name = models.CharField(max_length=40, unique=True)
     description = models.CharField(max_length=200)
     class_type = models.CharField(max_length=40)
-    configuration = jsonfield.JSONField(validators=[validate_json])
+    configuration = models.JSONField(validators=[validate_json])
     wiki_url = models.URLField(blank=True, null=True)
     creator = models.ForeignKey(
         User,
@@ -49,8 +48,55 @@ class ChoreVolunteer(models.Model):
         on_delete=models.CASCADE,
         related_name="chore",
     )
+
+    # Represents when the chore is scheduled to begin
     timestamp = models.IntegerField(null=False)
 
     created_at = models.DateTimeField(auto_now_add=True)
 
     history = HistoricalRecords()
+
+    @property
+    def first_name(self):
+        return self.user.first_name
+
+    @property
+    def full_name(self):
+        return f"{self.user.first_name} {self.user.last_name}"
+
+
+class ChoreNotification(models.Model):
+    event_key = models.CharField(max_length=128, unique=True)
+    chore = models.ForeignKey(
+        Chore,
+        null=False,
+        on_delete=models.CASCADE,
+        related_name="notifications",
+    )
+    recipient_user = models.ForeignKey(
+        User,
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="chore_notifications",
+    )
+
+    recipient_other = models.EmailField(null=True, blank=True)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    def clean(self):
+        from django.core.exceptions import ValidationError
+
+        if not self.recipient_user and not self.recipient_other:
+            raise ValidationError(
+                "Must have either a recipient_user or a recipient_other."
+            )
+        if self.recipient_user and self.recipient_other:
+            raise ValidationError(
+                "Cannot have both recipient_user and recipient_other."
+            )
+
+    def __str__(self):
+        recipient = self.recipient_user if self.recipient_user else self.recipient_other
+        return f"Notification to {recipient} for {self.chore} at {self.created_at}"
diff --git a/chores/templates/chores.html b/chores/templates/chores.html
index 88927163..a3334629 100644
--- a/chores/templates/chores.html
+++ b/chores/templates/chores.html
@@ -2,21 +2,20 @@
 
 {% block content %}
 
-<p>
-    Below is the list of chores for the next 3 months.
-</p>
-<p>
-    Please sign up for the activities you can help with. If a chore is getting close and nobody has signed up yet, the system will send out reminders.
-</p>
-<p>
-    For the engineers - this data is also accessible as a JSON from <code><a href="{% url "chores_api"%}">{% url "chores_api"%}</a></code>.
-</p>
-
 <div class="row">
 	<div class="col-xl-12 col-lg-12 col-sm-12">
 	<!-- Chores -->
     <div class="pt-0 pb-1">
         {% if event_groups %}
+            <p>
+                Below is the list of chores for the next 3 months.
+            </p>
+            <p>
+                Please sign up for the activities you can help with. If a chore is getting close and nobody has signed up yet, the system will send out reminders.
+            </p>
+            <p>
+                For the engineers - this data is also accessible as a JSON from <code><a href="{% url "chores_api"%}">{% url "chores_api"%}</a></code>.
+            </p>
             <div class="card mt-2 mb-2">
                 <ul class="list-group list-group-flush pt-0 pb-0">
                     {% for group in event_groups %}
@@ -47,15 +46,20 @@
                                                 <li style="list-style-type: none; padding-bottom:0 !important">
                                                     <div>
                                                         {% if volunteer == 'offer_volunteering' %}
-                                                            <a href="{% url 'signup_chore' chore_id=event.chore.chore_id ts=event.when.timestamp %}?redirect_to=chores" class="btn btn-outline-secondary btn-sm">Add me as volunteer</a>
+                                                            <a href="{% url 'signup_chore' chore_id=event.chore.chore_id ts=event.when.timestamp %}?redirect_to=chores"
+                                                                class="btn btn-outline-secondary btn-sm"
+                                                                data-test-hook="chores-volunteer-button">
+                                                                Add me as volunteer
+                                                            </a>
                                                         {% elif volunteer is None %}
                                                             <i>Volunteer needed</i>
                                                         {% elif volunteer.id  %}
-                                                            Volunteer:
-                                                            <a href="{{volunteer.path}}">
-                                                                {{ volunteer.first_name }}
-                                                            </a>
-
+                                                            <div data-test-hook="chores-volunteer">
+                                                                Volunteer:
+                                                                <a href="{{volunteer.path}}">
+                                                                    {{ volunteer.first_name }}
+                                                                </a>
+                                                            </div>
                                                         {% endif %}
                                                     </div>
                                                 </li>
@@ -65,7 +69,10 @@
                                             {% if event.user_volunteered %}
                                                 <li style="list-style-type: none; margin-top: 0.3em; padding-bottom:0 !important">
                                                     <div>
-                                                        <a href="{% url 'remove_signup_chore' chore_id=event.chore.chore_id ts=event.when.timestamp %}?redirect_to=chores" class="btn btn-outline-secondary btn-sm">Remove me as volunteer</a>
+                                                        <a href="{% url 'remove_signup_chore' chore_id=event.chore.chore_id ts=event.when.timestamp %}?redirect_to=chores"
+                                                            class="btn btn-outline-secondary btn-sm"
+                                                            data-test-hook="chores-remove-volunteer">
+                                                            Remove me as volunteer</a>
                                                     </div>
                                                 </li>
                                             {% endif %}
@@ -78,7 +85,13 @@
                 </ul>
             </div>
         {% else %}
-            No upcoming tasks for the next 2 weeks, view all upcoming chores <a href="{% url 'chores' %}" class="chores-link">here</a>.
+            <div data-test-hook="empty-chores" class="mt-2">
+                <p>No upcoming tasks for the next 3 months.</p>
+                <p>
+                    As a busy space with plenty to do that seems unlikely.<br/>
+                Something may be broken, let <a href="mailto:noc@makerspaceleiden.nl">noc@makerspaceleiden.nl</a>
+                </p>
+            </div>
         {% endif %}
     </div>
     </div>
diff --git a/chores/tests.py b/chores/tests.py
deleted file mode 100644
index a39b155a..00000000
--- a/chores/tests.py
+++ /dev/null
@@ -1 +0,0 @@
-# Create your tests here.
diff --git a/chores/tests/__init__.py b/chores/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/chores/tests/factories.py b/chores/tests/factories.py
new file mode 100644
index 00000000..a70443d5
--- /dev/null
+++ b/chores/tests/factories.py
@@ -0,0 +1,15 @@
+import factory
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+
+class UserFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = User
+
+    email = factory.Faker("email")
+    first_name = factory.Faker("first_name")
+    last_name = factory.Faker("last_name")
+    telegram_user_id = factory.Faker("uuid4")
+    password = factory.PostGenerationMethodCall("set_password", "password123")
diff --git a/chores/tests/fixtures/api_schema.json b/chores/tests/fixtures/api_schema.json
new file mode 100644
index 00000000..79d81e94
--- /dev/null
+++ b/chores/tests/fixtures/api_schema.json
@@ -0,0 +1,96 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "",
+  "type": "object",
+  "properties": {
+    "title": {
+      "type": "string",
+      "minLength": 1
+    },
+    "version": {
+      "type": "string",
+      "minLength": 1
+    },
+    "chores": {
+      "type": "array",
+      "uniqueItems": true,
+      "minItems": 1,
+      "items": {
+        "required": ["ts_str", "timestamp"],
+        "properties": {
+          "ts_str": {
+            "type": "string",
+            "minLength": 1
+          },
+          "timestamp": {
+            "type": "number"
+          },
+          "events": {
+            "type": "array",
+            "uniqueItems": true,
+            "minItems": 1,
+            "items": {
+              "required": ["time_str", "wiki_url"],
+              "properties": {
+                "chore": {
+                  "type": "object",
+                  "properties": {
+                    "chore_id": {
+                      "type": "number"
+                    },
+                    "description": {
+                      "type": "string",
+                      "minLength": 1
+                    },
+                    "min_required_people": {
+                      "type": "number"
+                    },
+                    "name": {
+                      "type": "string",
+                      "minLength": 1
+                    }
+                  },
+                  "required": [
+                    "chore_id",
+                    "description",
+                    "min_required_people",
+                    "name"
+                  ]
+                },
+                "when": {
+                  "type": "object",
+                  "properties": {
+                    "human_str": {
+                      "type": "string",
+                      "minLength": 1
+                    },
+                    "timestamp": {
+                      "type": "number"
+                    }
+                  },
+                  "required": ["human_str", "timestamp"]
+                },
+                "time_str": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "volunteers": {
+                  "type": "array",
+                  "items": {
+                    "required": [],
+                    "properties": {}
+                  }
+                },
+                "wiki_url": {
+                  "type": "string",
+                  "minLength": 1
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "required": ["title", "version", "chores"]
+}
diff --git a/chores/tests/test_api.py b/chores/tests/test_api.py
new file mode 100644
index 00000000..0b9b05b9
--- /dev/null
+++ b/chores/tests/test_api.py
@@ -0,0 +1,98 @@
+import json
+
+import time_machine
+from django.contrib.auth import get_user_model
+from django.test import TestCase
+from django.urls import reverse
+from faker import Faker
+from rest_framework import status
+
+from ..models import Chore
+from .factories import UserFactory
+
+fake = Faker()
+
+User = get_user_model()
+
+
+# Load the schema from a file
+def load_schema(schema_path):
+    with open(schema_path, "r") as schema_file:
+        return json.load(schema_file)
+
+
+class ChoresAPITest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    def test_empty_chores_api_list_endpoint_returns_404(self):
+        """Test that the chores API list endpoint returns a 404 response"""
+        url = reverse("chores_api")
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_chores_api_list_endpoint_returns_200(self):
+        """Test that the chores API list endpoint returns a 200 response"""
+        url = reverse("chores_api")
+        Chore.objects.create(
+            name=fake.name(),
+            description="A test chore that needs volunteers.",
+            class_type="BasicChore",
+            wiki_url=fake.url(),
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "gentle_email_reminder",
+                                "destination": "test@example.com",
+                                "subject_template": "Volunteers needed next week",
+                                "body_template": "Hallo, we hebben {num_volunteers_needed} vrijwilliger nodig volgende week.\n\nOm stof in onze makerspace tegen te gaan willen we je vragen om te stofzuigen in de voorste ruimte en de houtwerkplaats, en eventueel de grote hal. \n\nAls je daar zin in hebt kun je ook de voorste ruimte dweilen met de hippe turbodweil die we hebben, maar als je weinig tijd hebt: Met alleen stofzuigen is al veel te winnen.\n\nDeze taak kan op elk moment gedurende de week worden gedaan. Je helpt wanneer het jou uitkomt, alle hulp is welkom!\n\nInformatie over schoonmaken op de Wiki: https://wiki.makerspaceleiden.nl/mediawiki/index.php/Chore_-_Dedustify \n\n\nClick here to sign up: {signup_url}",
+                            }
+                        ],
+                    },
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 6, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "hard_email_reminder",
+                                "destination": "test@example.com",
+                                "subject_template": "Volunteers REALLY needed for this week",
+                                "body_template": "Hallo, we hebben nog steeds {num_volunteers_needed} vrijwilliger nodig voor deze week.\n\nOm stof in onze makerspace tegen te gaan willen we je vragen om te stofzuigen in de voorste ruimte en de houtwerkplaats, en eventueel de grote hal. \n\nAls je daar zin in hebt kun je ook de voorste ruimte dweilen met de hippe turbodweil die we hebben, maar als je weinig tijd hebt: Met alleen stofzuigen is al veel te winnen.\n\nDeze taak kan op elk moment gedurende de week worden gedaan. Je helpt wanneer het jou uitkomt, alle hulp is welkom!\n\nInformatie over schoonmaken op de Wiki: https://wiki.makerspaceleiden.nl/mediawiki/index.php/Chore_-_Dedustify \n\nClick here to sign up: {signup_url}",
+                            }
+                        ],
+                    },
+                    {
+                        "reminder_type": "volunteers_who_signed_up",
+                        "when": {"days_before": 7, "time": "19:00"},
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        jsonBody = json.loads(response.content)
+        print("------------------------------------------------")
+        self.assertEqual(len(jsonBody["chores"]), 6)
+
+        # LADEBUG: Fixme
+        # schema = load_schema(
+        #     os.path.join(os.path.dirname(__file__), "./fixtures/api_schema.json")
+        # )
+        # jsonschema.validate(jsonBody, schema)
diff --git a/chores/tests/test_commands.py b/chores/tests/test_commands.py
new file mode 100644
index 00000000..4fff9c26
--- /dev/null
+++ b/chores/tests/test_commands.py
@@ -0,0 +1,690 @@
+# Create your tests here.
+import random
+from io import StringIO
+
+import time_machine
+from django.core import mail
+from django.core.management import call_command
+from django.test import TestCase
+
+from ..models import Chore, ChoreNotification, ChoreVolunteer
+from .factories import UserFactory
+
+
+class CustomCommandTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory(
+            email="chore.author@example.com",
+        )
+
+    @time_machine.travel("2025-07-10 19:56")
+    def test_email_asking_for_volunteers(self):
+        # Arrange
+
+        # Create a chore that requires a volunteer
+        # Switch to faker for generating these email addresses
+        nudge_destination = "deelnemers@makerspaceleiden.nl"
+        Chore.objects.create(
+            name="Test Chore",
+            description="A test chore that needs volunteers.",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "gentle_email_reminder",
+                                "destination": nudge_destination,
+                                "subject_template": "Volunteers needed next week",
+                                "body_template": "Hallo, we hebben {num_volunteers_needed} vrijwilliger nodig volgende week.\n\nOm stof in onze makerspace tegen te gaan willen we je vragen om te stofzuigen in de voorste ruimte en de houtwerkplaats, en eventueel de grote hal. \n\nAls je daar zin in hebt kun je ook de voorste ruimte dweilen met de hippe turbodweil die we hebben, maar als je weinig tijd hebt: Met alleen stofzuigen is al veel te winnen.\n\nDeze taak kan op elk moment gedurende de week worden gedaan. Je helpt wanneer het jou uitkomt, alle hulp is welkom!\n\nInformatie over schoonmaken op de Wiki: https://wiki.makerspaceleiden.nl/mediawiki/index.php/Chore_-_Dedustify \n\n\nClick here to sign up: {signup_url}",
+                            }
+                        ],
+                    },
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 6, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "hard_email_reminder",
+                                "destination": nudge_destination,
+                                "subject_template": "Volunteers REALLY needed for this week",
+                                "body_template": "Hallo, we hebben nog steeds {num_volunteers_needed} vrijwilliger nodig voor deze week.\n\nOm stof in onze makerspace tegen te gaan willen we je vragen om te stofzuigen in de voorste ruimte en de houtwerkplaats, en eventueel de grote hal. \n\nAls je daar zin in hebt kun je ook de voorste ruimte dweilen met de hippe turbodweil die we hebben, maar als je weinig tijd hebt: Met alleen stofzuigen is al veel te winnen.\n\nDeze taak kan op elk moment gedurende de week worden gedaan. Je helpt wanneer het jou uitkomt, alle hulp is welkom!\n\nInformatie over schoonmaken op de Wiki: https://wiki.makerspaceleiden.nl/mediawiki/index.php/Chore_-_Dedustify \n\nClick here to sign up: {signup_url}",
+                            }
+                        ],
+                    },
+                    {
+                        "reminder_type": "volunteers_who_signed_up",
+                        "when": {"days_before": 7, "time": "19:00"},
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        out = StringIO()
+
+        # Act – run at least once to ensure duplicate notifications are not created
+        n = random.randint(2, 4)
+        for _ in range(n):
+            call_command("send_reminders", stdout=out)
+
+        # Assert that an email was sent
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertEqual(ChoreNotification.objects.count(), 1)
+        chore_notification = ChoreNotification.objects.first()
+        self.assertEqual(nudge_destination, chore_notification.recipient_other)
+        email = mail.outbox[0]
+        self.assertIn(nudge_destination, email.to)
+        self.assertIn("Volunteers needed next week", email.subject)
+        self.assertIn("Hallo, we hebben 1 vrijwilliger", email.body)
+
+    @time_machine.travel("2025-07-14 19:56")
+    def test_urgent_email_asking_for_volunteers(self):
+        # Arrange
+        # Create a chore that requires a volunteer
+        # Switch to faker for generating these email addresses
+        nudge_destination = "deelnemers@makerspaceleiden.nl"
+        Chore.objects.create(
+            name="Test Chore",
+            description="A test chore that needs volunteers.",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "gentle_email_reminder",
+                                "destination": nudge_destination,
+                                "subject_template": "Volunteers needed next week",
+                                "body_template": "Hallo, we hebben {num_volunteers_needed} vrijwilliger nodig volgende week.\n\nOm stof in onze makerspace tegen te gaan willen we je vragen om te stofzuigen in de voorste ruimte en de houtwerkplaats, en eventueel de grote hal. \n\nAls je daar zin in hebt kun je ook de voorste ruimte dweilen met de hippe turbodweil die we hebben, maar als je weinig tijd hebt: Met alleen stofzuigen is al veel te winnen.\n\nDeze taak kan op elk moment gedurende de week worden gedaan. Je helpt wanneer het jou uitkomt, alle hulp is welkom!\n\nInformatie over schoonmaken op de Wiki: https://wiki.makerspaceleiden.nl/mediawiki/index.php/Chore_-_Dedustify \n\n\nClick here to sign up: {signup_url}",
+                            }
+                        ],
+                    },
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 6, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "hard_email_reminder",
+                                "destination": nudge_destination,
+                                "subject_template": "Volunteers REALLY needed for this week",
+                                "body_template": "Hallo, we hebben nog steeds {num_volunteers_needed} vrijwilliger nodig voor deze week.\n\nOm stof in onze makerspace tegen te gaan willen we je vragen om te stofzuigen in de voorste ruimte en de houtwerkplaats, en eventueel de grote hal. \n\nAls je daar zin in hebt kun je ook de voorste ruimte dweilen met de hippe turbodweil die we hebben, maar als je weinig tijd hebt: Met alleen stofzuigen is al veel te winnen.\n\nDeze taak kan op elk moment gedurende de week worden gedaan. Je helpt wanneer het jou uitkomt, alle hulp is welkom!\n\nInformatie over schoonmaken op de Wiki: https://wiki.makerspaceleiden.nl/mediawiki/index.php/Chore_-_Dedustify \n\nClick here to sign up: {signup_url}",
+                            }
+                        ],
+                    },
+                    {
+                        "reminder_type": "volunteers_who_signed_up",
+                        "when": {"days_before": 7, "time": "19:00"},
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+        out = StringIO()
+
+        # Act – run at least once to ensure duplicate notifications are not created
+        n = random.randint(2, 4)
+        for _ in range(n):
+            call_command("send_reminders", stdout=out)
+
+        # Assert that emails were sent
+        self.assertEqual(len(mail.outbox), 2)
+        self.assertGreaterEqual(ChoreNotification.objects.count(), 1)
+        chore_notification = ChoreNotification.objects.last()
+        self.assertEqual(nudge_destination, chore_notification.recipient_other)
+        email = mail.outbox[1]
+        self.assertIn(nudge_destination, email.to)
+        self.assertIn("Volunteers REALLY needed for this week", email.subject)
+        self.assertIn("Hallo, we hebben nog steeds 1 vrijwilliger", email.body)
+
+    @time_machine.travel("2025-07-13 21:56")
+    def test_email_reminding_volunteers(self):
+        # Arrange
+        # Create a chore that requires a volunteer
+        # Switch to faker for generating these email addresses
+        nudge_destination = "deelnemers@makerspaceleiden.nl"
+        chore = Chore.objects.create(
+            name="Test Chore",
+            description="A test chore that needs volunteers.",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "gentle_email_reminder",
+                                "destination": nudge_destination,
+                                "subject_template": "Volunteers needed next week",
+                                "body_template": "Hallo, we hebben {num_volunteers_needed} vrijwilliger nodig volgende week.\n\nOm stof in onze makerspace tegen te gaan willen we je vragen om te stofzuigen in de voorste ruimte en de houtwerkplaats, en eventueel de grote hal. \n\nAls je daar zin in hebt kun je ook de voorste ruimte dweilen met de hippe turbodweil die we hebben, maar als je weinig tijd hebt: Met alleen stofzuigen is al veel te winnen.\n\nDeze taak kan op elk moment gedurende de week worden gedaan. Je helpt wanneer het jou uitkomt, alle hulp is welkom!\n\nInformatie over schoonmaken op de Wiki: https://wiki.makerspaceleiden.nl/mediawiki/index.php/Chore_-_Dedustify \n\n\nClick here to sign up: {signup_url}",
+                            }
+                        ],
+                    },
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 6, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "hard_email_reminder",
+                                "destination": nudge_destination,
+                                "subject_template": "Volunteers REALLY needed for this week",
+                                "body_template": "Hallo, we hebben nog steeds {num_volunteers_needed} vrijwilliger nodig voor deze week.\n\nOm stof in onze makerspace tegen te gaan willen we je vragen om te stofzuigen in de voorste ruimte en de houtwerkplaats, en eventueel de grote hal. \n\nAls je daar zin in hebt kun je ook de voorste ruimte dweilen met de hippe turbodweil die we hebben, maar als je weinig tijd hebt: Met alleen stofzuigen is al veel te winnen.\n\nDeze taak kan op elk moment gedurende de week worden gedaan. Je helpt wanneer het jou uitkomt, alle hulp is welkom!\n\nInformatie over schoonmaken op de Wiki: https://wiki.makerspaceleiden.nl/mediawiki/index.php/Chore_-_Dedustify \n\nClick here to sign up: {signup_url}",
+                            }
+                        ],
+                    },
+                    {
+                        "reminder_type": "volunteers_who_signed_up",
+                        "when": {"days_before": 7, "time": "19:00"},
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+        volunteeruser = UserFactory(
+            email="chore.volunteer@example.com",
+        )
+        ChoreVolunteer.objects.create(
+            user=volunteeruser, chore=chore, timestamp=1753041600
+        )
+
+        out = StringIO()
+
+        # Act – run at least once to ensure duplicate notifications are not created
+        n = random.randint(2, 3)
+        for _ in range(n):
+            call_command("send_reminders", stdout=out)
+
+        # Assert that emails were sent
+        self.assertEqual(ChoreNotification.objects.all().count(), 1)
+        chore_notification = ChoreNotification.objects.last()
+        self.assertIsNone(chore_notification.recipient_other)
+        self.assertEqual(volunteeruser, chore_notification.recipient_user)
+        self.assertEqual(len(mail.outbox), 1)
+        email = mail.outbox[0]
+        self.assertIn(volunteeruser.email, email.to)
+        self.assertIn("Volunteering reminder", email.subject)
+        self.assertIn("friendly reminder that you signed up for", email.body)
+
+
+class SingleOccurrenceChoreTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    @time_machine.travel("2025-07-10 19:56")
+    def test_single_occurrence_chore_reminder(self):
+        """Test reminder for single occurrence chore"""
+        nudge_destination = "deelnemers@makerspaceleiden.nl"
+        Chore.objects.create(
+            name="Single Event Chore",
+            description="A one-time chore",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "single_occurrence",
+                    "event_time": "21/7/2025 8:00",
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "single_occurrence_reminder",
+                                "destination": nudge_destination,
+                                "subject_template": "Single event reminder",
+                                "body_template": "Reminder for single event: {event_day}",
+                            }
+                        ],
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        out = StringIO()
+        call_command("send_reminders", stdout=out)
+
+        # Should not send reminder since event is in the future
+        self.assertEqual(len(mail.outbox), 0)
+        self.assertEqual(ChoreNotification.objects.count(), 0)
+
+
+class NoVolunteersNeededTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    @time_machine.travel("2025-07-10 19:56")
+    def test_no_reminder_when_volunteers_exist(self):
+        """Test that no reminder is sent when volunteers are already signed up"""
+        nudge_destination = "deelnemers@makerspaceleiden.nl"
+        chore = Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "gentle_email_reminder",
+                                "destination": nudge_destination,
+                                "subject_template": "Test reminder",
+                                "body_template": "Test body",
+                            }
+                        ],
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        # Create a volunteer
+        volunteer_user = UserFactory()
+        ChoreVolunteer.objects.create(
+            user=volunteer_user,
+            chore=chore,
+            timestamp=1753041600,
+        )
+
+        out = StringIO()
+        call_command("send_reminders", stdout=out)
+
+        # Should not send reminder since volunteer is already signed up
+        self.assertEqual(len(mail.outbox), 0)
+        self.assertEqual(ChoreNotification.objects.count(), 0)
+
+
+class InvalidChoreTypeTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    def test_invalid_chore_type_raises_exception(self):
+        """Test that invalid chore type raises exception"""
+        Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="InvalidChoreType",
+            configuration={"min_required_people": 1},
+            creator=self.user,
+        )
+
+        out = StringIO()
+        with self.assertRaises(
+            Exception
+        ):  # Should raise exception for invalid chore type
+            call_command("send_reminders", stdout=out)
+
+
+class InvalidReminderTypeTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    def test_invalid_reminder_type_raises_exception(self):
+        """Test that invalid reminder type raises exception"""
+        Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "invalid_reminder_type",
+                        "when": {"days_before": 10, "time": "17:00"},
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        out = StringIO()
+        with self.assertRaises(
+            Exception
+        ):  # Should raise exception for invalid reminder type
+            call_command("send_reminders", stdout=out)
+
+
+class MultipleVolunteersTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    @time_machine.travel("2025-07-13 21:56")
+    def test_multiple_volunteers_reminder(self):
+        """Test reminder for multiple volunteers"""
+        chore = Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 2,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "volunteers_who_signed_up",
+                        "when": {"days_before": 7, "time": "19:00"},
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        # Create multiple volunteers
+        volunteer1 = UserFactory(
+            email="volunteer1@example.com",
+        )
+        volunteer2 = UserFactory(
+            email="volunteer2@example.com",
+        )
+
+        ChoreVolunteer.objects.create(
+            user=volunteer1,
+            chore=chore,
+            timestamp=1753041600,
+        )
+        ChoreVolunteer.objects.create(
+            user=volunteer2,
+            chore=chore,
+            timestamp=1753041600,
+        )
+
+        out = StringIO()
+        call_command("send_reminders", stdout=out)
+
+        # Should send reminders to both volunteers
+        self.assertEqual(len(mail.outbox), 2)
+        self.assertEqual(ChoreNotification.objects.count(), 2)
+
+        # Check that both volunteers received notifications
+        notification_emails = [email.to[0] for email in mail.outbox]
+        self.assertIn(volunteer1.email, notification_emails)
+        self.assertIn(volunteer2.email, notification_emails)
+
+
+class MultipleChoresTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    @time_machine.travel("2025-07-10 19:56")
+    def test_multiple_chores_processed(self):
+        """Test that multiple chores are processed correctly"""
+        # Create multiple chores
+        chore1 = Chore.objects.create(
+            name="Chore 1",
+            description="First test chore",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "chore1_reminder",
+                                "destination": "deelnemers@makerspaceleiden.nl",
+                                "subject_template": "Chore 1 reminder",
+                                "body_template": "Reminder for chore 1",
+                            }
+                        ],
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        chore2 = Chore.objects.create(
+            name="Chore 2",
+            description="Second test chore",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "chore2_reminder",
+                                "destination": "deelnemers@makerspaceleiden.nl",
+                                "subject_template": "Chore 2 reminder",
+                                "body_template": "Reminder for chore 2",
+                            }
+                        ],
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        out = StringIO()
+        call_command("send_reminders", stdout=out)
+
+        # Should send reminders for both chores
+        self.assertEqual(len(mail.outbox), 2)
+        self.assertEqual(ChoreNotification.objects.count(), 2)
+
+        # Check that both chores generated notifications
+        notification_chores = [
+            notification.chore for notification in ChoreNotification.objects.all()
+        ]
+        self.assertIn(chore1, notification_chores)
+        self.assertIn(chore2, notification_chores)
+
+
+class NoChoresTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    @time_machine.travel("2025-07-10 19:56")
+    def test_no_chores_no_emails(self):
+        """Test that no emails are sent when no chores exist"""
+        out = StringIO()
+        call_command("send_reminders", stdout=out)
+
+        # Should not send any emails when no chores exist
+        self.assertEqual(len(mail.outbox), 0)
+        self.assertEqual(ChoreNotification.objects.count(), 0)
+
+
+class FutureEventTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    @time_machine.travel("2025-07-10 19:56")
+    def test_future_event_no_reminder(self):
+        """Test that no reminder is sent for future events"""
+        Chore.objects.create(
+            name="Future Chore",
+            description="A chore with future events",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2025 8:00",  # Future date
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "future_reminder",
+                                "destination": "deelnemers@makerspaceleiden.nl",
+                                "subject_template": "Future reminder",
+                                "body_template": "Future reminder body",
+                            }
+                        ],
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        out = StringIO()
+        call_command("send_reminders", stdout=out)
+
+        # Should not send reminder for future events
+        self.assertEqual(len(mail.outbox), 0)
+        self.assertEqual(ChoreNotification.objects.count(), 0)
+
+
+class VolunteerCrossContaminationTest(TestCase):
+    """Test the defect where volunteers from one chore incorrectly affect another chore's reminder logic"""
+
+    def setUp(self):
+        self.user = UserFactory()
+
+    @time_machine.travel("2025-07-10 19:56")
+    def test_volunteer_cross_contamination_defect(self):
+        """Test that volunteers from one chore do not prevent reminders for another chore"""
+        # Create first chore that needs volunteers
+        chore1 = Chore.objects.create(
+            name="Chore 1 - Needs Volunteers",
+            description="A chore that needs volunteers",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "chore1_reminder",
+                                "destination": "deelnemers@makerspaceleiden.nl",
+                                "subject_template": "Chore 1 needs volunteers",
+                                "body_template": "Chore 1 needs volunteers",
+                            }
+                        ],
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        # Create second chore that also needs volunteers
+        Chore.objects.create(
+            name="Chore 2 - Needs Volunteers",
+            description="Another chore that needs volunteers",
+            class_type="BasicChore",
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [
+                    {
+                        "reminder_type": "missing_volunteers",
+                        "when": {"days_before": 10, "time": "17:00"},
+                        "nudges": [
+                            {
+                                "nudge_type": "email",
+                                "nudge_key": "chore2_reminder",
+                                "destination": "deelnemers@makerspaceleiden.nl",
+                                "subject_template": "Chore 2 needs volunteers",
+                                "body_template": "Chore 2 needs volunteers",
+                            }
+                        ],
+                    },
+                ],
+            },
+            creator=self.user,
+        )
+
+        # Create a volunteer for chore1 only
+        volunteer = UserFactory()
+        ChoreVolunteer.objects.create(
+            user=volunteer,
+            chore=chore1,  # Only volunteer for chore1
+            timestamp=1753041600,
+        )
+
+        out = StringIO()
+        call_command("send_reminders", stdout=out)
+
+        # Verify that chore2 should have gotten a reminder if the bug was fixed
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertIn("Chore 2 needs volunteers", mail.outbox[0].subject)
diff --git a/chores/tests/test_models.py b/chores/tests/test_models.py
new file mode 100644
index 00000000..ea6b5191
--- /dev/null
+++ b/chores/tests/test_models.py
@@ -0,0 +1,155 @@
+# Model tests for chores app
+from django.core.exceptions import ValidationError
+from django.test import TestCase
+
+from ..models import Chore, ChoreNotification, ChoreVolunteer
+from .factories import UserFactory
+
+
+class ChoreModelTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+
+    def test_chore_creation(self):
+        """Test basic chore creation"""
+        chore = Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="BasicChore",
+            configuration={"min_required_people": 1},
+            creator=self.user,
+        )
+        self.assertEqual(chore.name, "Test Chore")
+        self.assertEqual(chore.description, "A test chore")
+        self.assertEqual(chore.class_type, "BasicChore")
+        self.assertEqual(chore.creator, self.user)
+
+    def test_chore_str_representation(self):
+        """Test string representation of chore"""
+        chore = Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="BasicChore",
+            configuration={"min_required_people": 1},
+            creator=self.user,
+        )
+        self.assertEqual(str(chore), "Test Chore")
+
+    def test_chore_unique_name_constraint(self):
+        """Test that chore names must be unique"""
+        Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="BasicChore",
+            configuration={"min_required_people": 1},
+            creator=self.user,
+        )
+
+        with self.assertRaises(Exception):  # Should raise IntegrityError
+            Chore.objects.create(
+                name="Test Chore",  # Same name
+                description="Another test chore",
+                class_type="BasicChore",
+                configuration={"min_required_people": 1},
+                creator=self.user,
+            )
+
+
+class ChoreVolunteerModelTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory()
+        self.chore = Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="BasicChore",
+            configuration={"min_required_people": 1},
+            creator=self.user,
+        )
+
+    def test_chore_volunteer_creation(self):
+        """Test basic chore volunteer creation"""
+        volunteer = ChoreVolunteer.objects.create(
+            user=self.user,
+            chore=self.chore,
+            timestamp=1753041600,
+        )
+        self.assertEqual(volunteer.user, self.user)
+        self.assertEqual(volunteer.chore, self.chore)
+        self.assertEqual(volunteer.timestamp, 1753041600)
+
+    def test_chore_volunteer_properties(self):
+        """Test chore volunteer properties"""
+        volunteer = ChoreVolunteer.objects.create(
+            user=self.user,
+            chore=self.chore,
+            timestamp=1753041600,
+        )
+        self.assertEqual(volunteer.first_name, self.user.first_name)
+        self.assertEqual(volunteer.full_name, self.user.full_name)
+
+
+class ChoreNotificationModelTest(TestCase):
+    def setUp(self):
+        self.user = self.user = UserFactory()
+        self.chore = Chore.objects.create(
+            name="Test Chore",
+            description="A test chore",
+            class_type="BasicChore",
+            configuration={"min_required_people": 1},
+            creator=self.user,
+        )
+
+    def test_notification_with_user_recipient(self):
+        """Test notification creation with user recipient"""
+        notification = ChoreNotification.objects.create(
+            event_key="test-key-123",
+            chore=self.chore,
+            recipient_user=self.user,
+        )
+        self.assertEqual(notification.event_key, "test-key-123")
+        self.assertEqual(notification.chore, self.chore)
+        self.assertEqual(notification.recipient_user, self.user)
+        self.assertIsNone(notification.recipient_other)
+
+    def test_notification_with_email_recipient(self):
+        """Test notification creation with email recipient"""
+        notification = ChoreNotification.objects.create(
+            event_key="test-key-456",
+            chore=self.chore,
+            recipient_other="test@example.com",
+        )
+        self.assertEqual(notification.event_key, "test-key-456")
+        self.assertEqual(notification.chore, self.chore)
+        self.assertIsNone(notification.recipient_user)
+        self.assertEqual(notification.recipient_other, "test@example.com")
+
+    def test_notification_validation_both_recipients(self):
+        """Test that notification cannot have both user and email recipients"""
+        notification = ChoreNotification(
+            event_key="test-key-789",
+            chore=self.chore,
+            recipient_user=self.user,
+            recipient_other="test@example.com",
+        )
+        with self.assertRaises(ValidationError):
+            notification.clean()
+
+    def test_notification_validation_no_recipients(self):
+        """Test that notification must have at least one recipient"""
+        notification = ChoreNotification(
+            event_key="test-key-789",
+            chore=self.chore,
+        )
+        with self.assertRaises(ValidationError):
+            notification.clean()
+
+    def test_notification_str_representation(self):
+        """Test string representation of notification"""
+        notification = ChoreNotification.objects.create(
+            event_key="test-key-123",
+            chore=self.chore,
+            recipient_user=self.user,
+        )
+        self.assertIn("Notification to", str(notification))
+        self.assertIn(self.user.full_name, str(notification))
+        self.assertIn("Test Chore", str(notification))
diff --git a/chores/tests/test_views.py b/chores/tests/test_views.py
new file mode 100644
index 00000000..3b2df136
--- /dev/null
+++ b/chores/tests/test_views.py
@@ -0,0 +1,213 @@
+import json
+
+import time_machine
+from django.contrib.auth import get_user_model
+from django.core import mail
+from django.test import TestCase
+from django.urls import reverse
+from faker import Faker
+from rest_framework import status
+
+from ..models import Chore, ChoreVolunteer
+from .factories import UserFactory
+
+fake = Faker()
+
+User = get_user_model()
+
+
+# Load the schema from a file
+def load_schema(schema_path):
+    with open(schema_path, "r") as schema_file:
+        return json.load(schema_file)
+
+
+class ChoresViewsTest(TestCase):
+    def setUp(self):
+        self.user = UserFactory(password="testpassword")
+
+    @time_machine.travel("2025-07-13 14:56")
+    def create_chore(self, **kwargs):
+        defaults = dict(
+            name=fake.name(),
+            description="A test chore that needs volunteers.",
+            class_type="BasicChore",
+            wiki_url=fake.url(),
+            configuration={
+                "min_required_people": 1,
+                "events_generation": {
+                    "event_type": "recurrent",
+                    "starting_time": "21/7/2021 8:00",
+                    "crontab": "0 22 * * sun",
+                    "take_one_every": 2,
+                },
+                "reminders": [],
+            },
+            creator=self.user,
+        )
+        defaults.update(kwargs)
+        return Chore.objects.create(**defaults)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_empty_chores_overview_200(self):
+        """Test that the empty chores overview returns a 200 response"""
+        url = reverse("chores")
+        success = self.client.login(email=self.user.email, password="testpassword")
+        self.assertTrue(success)
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn('data-test-hook="empty-chores"', response.content.decode("utf-8"))
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_chores_overview_with_chore_200(self):
+        url = reverse("chores")
+        chore = self.create_chore()
+
+        success = self.client.login(email=self.user.email, password="testpassword")
+        self.assertTrue(success)
+        response = self.client.get(url)
+        html = response.content.decode("utf-8")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn(chore.description, html)
+        self.assertIn('data-test-hook="chores-volunteer-button"', html)
+        self.assertNotIn('data-test-hook="chores-volunteer"', html)
+        self.assertNotIn('data-test-hook="empty-chores"', html)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_chores_overview_with_chore_and_volunteer_200(self):
+        url = reverse("chores")
+        chore = self.create_chore()
+        volunteer = UserFactory()
+        ChoreVolunteer.objects.create(user=volunteer, chore=chore, timestamp=1753041600)
+
+        success = self.client.login(email=self.user.email, password="testpassword")
+        self.assertTrue(success)
+        response = self.client.get(url)
+        html = response.content.decode("utf-8")
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn(chore.description, html)
+        self.assertIn('data-test-hook="chores-volunteer"', html)
+        self.assertIn(volunteer.first_name, html)
+        self.assertNotIn('data-test-hook="empty-chores"', html)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_signup_success(self):
+        chore = self.create_chore()
+        ts = 1753041600
+        url = reverse("signup_chore", args=[chore.id, ts])
+        self.client.login(email=self.user.email, password="testpassword")
+        response = self.client.get(url + "?redirect_to=chores")
+        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
+        self.assertIn("chores", response.url)
+        self.assertTrue(
+            ChoreVolunteer.objects.filter(
+                user=self.user, chore=chore, timestamp=ts
+            ).exists()
+        )
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertIn("volunteer", mail.outbox[0].body)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_signup_chore_not_found(self):
+        self.client.login(email=self.user.email, password="testpassword")
+        url = reverse("signup_chore", args=[9999, 1753041600])
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+        self.assertIn("Chore not found", response.content.decode())
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_signup_double(self):
+        chore = self.create_chore()
+        ts = 1753041600
+        ChoreVolunteer.objects.create(user=self.user, chore=chore, timestamp=ts)
+        self.client.login(email=self.user.email, password="testpassword")
+        url = reverse("signup_chore", args=[chore.id, ts])
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
+        # Should not create duplicate
+        self.assertEqual(
+            ChoreVolunteer.objects.filter(
+                user=self.user, chore=chore, timestamp=ts
+            ).count(),
+            2,
+        )
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_signup_requires_login(self):
+        chore = self.create_chore()
+        ts = 1753041600
+        url = reverse("signup_chore", args=[chore.id, ts])
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
+        self.assertIn("/login/", response.url)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_remove_signup_success(self):
+        chore = self.create_chore()
+        ts = 1753041600
+        ChoreVolunteer.objects.create(user=self.user, chore=chore, timestamp=ts)
+        self.client.login(email=self.user.email, password="testpassword")
+        url = reverse("remove_signup_chore", args=[chore.id, ts])
+        response = self.client.get(url + "?redirect_to=chores")
+        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
+        self.assertIn("/chores", response.url)
+        self.assertFalse(
+            ChoreVolunteer.objects.filter(
+                user=self.user, chore=chore, timestamp=ts
+            ).exists()
+        )
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertIn("can no longer volunteer", mail.outbox[0].body)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_remove_signup_chore_not_found(self):
+        self.client.login(email=self.user.email, password="testpassword")
+        url = reverse("remove_signup_chore", args=[9999, 1753041600])
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+        self.assertIn("Chore not found", response.content.decode())
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_remove_signup_not_signed_up(self):
+        chore = self.create_chore()
+        ts = 1753041600
+        self.client.login(email=self.user.email, password="testpassword")
+        url = reverse("remove_signup_chore", args=[chore.id, ts])
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
+        self.assertFalse(
+            ChoreVolunteer.objects.filter(
+                user=self.user, chore=chore, timestamp=ts
+            ).exists()
+        )
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertIn("can no longer volunteer", mail.outbox[0].body)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_remove_signup_requires_login(self):
+        chore = self.create_chore()
+        ts = 1753041600
+        url = reverse("remove_signup_chore", args=[chore.id, ts])
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
+        self.assertIn("login/", response.url)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_index_requires_login(self):
+        url = reverse("chores")
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
+        self.assertIn("/login/", response.url)
+
+    @time_machine.travel("2025-07-13 14:56")
+    def test_remove_me_as_volunteer_button_visible_for_volunteer(self):
+        """Test that the 'Remove me as volunteer' button is visible for the logged-in user who volunteered."""
+        chore = self.create_chore()
+        ts = 1753041600
+        # The logged-in user volunteers for the chore
+        ChoreVolunteer.objects.create(user=self.user, chore=chore, timestamp=ts)
+        self.client.login(email=self.user.email, password="testpassword")
+        url = reverse("chores")
+        response = self.client.get(url)
+        html = response.content.decode("utf-8")
+        self.assertIn('data-test-hook="chores-remove-volunteer"', html)
diff --git a/chores/utils.py b/chores/utils.py
index 3d899950..49326b36 100644
--- a/chores/utils.py
+++ b/chores/utils.py
@@ -8,6 +8,7 @@
 from .models import Chore, ChoreVolunteer
 
 
+# LADEBUG: Fix loading from chores
 def get_chores_data(current_user_id=None, subset=None):
     aggregator_adapter = get_aggregator_adapter()
     if not aggregator_adapter:
@@ -29,6 +30,7 @@ def get_chores_data(current_user_id=None, subset=None):
         key = f"{turn.chore.id}-{turn.timestamp}"
         volunteers_by_key[key].append(turn.user)
 
+    # TODO: Drop use of aggregator virtualisation, internalise to CRM
     data = aggregator_adapter.get_chores()
     if data is None:
         return None, "No data available"
diff --git a/chores/views.py b/chores/views.py
index a205ee6d..75330ee7 100644
--- a/chores/views.py
+++ b/chores/views.py
@@ -12,20 +12,24 @@
 from django.shortcuts import redirect, render
 from django.template.loader import render_to_string
 
-from selfservice.aggregator_adapter import get_aggregator_adapter
-
+from .core import ChoreEventsLogic, Time
 from .models import Chore, ChoreVolunteer
 
 logger = logging.getLogger(__name__)
 
+NUMBER_OF_DAYS_AHEAD = 90
 
-def getall(current_user_id=None, subset=None):
-    aggregator_adapter = get_aggregator_adapter()
-    if not aggregator_adapter:
-        return HttpResponse(
-            "No aggregator configuration found", status=500, content_type="text/plain"
-        )
 
+def chores_get_all_from(now):
+    then = now + (NUMBER_OF_DAYS_AHEAD * 24 * 60 * 60)  # Add 14 days
+    chores = Chore.objects.all()
+    data = ChoreEventsLogic(chores).get_events_from_to(
+        Time.from_timestamp(now), Time.from_timestamp(then)
+    )
+    return [e.for_json() for e in data]
+
+
+def getall(current_user_id=None, subset=None):
     now = time.time()
     volunteers_turns = ChoreVolunteer.objects.filter(timestamp__gte=now)
     volunteers_by_key = defaultdict(list)
@@ -33,12 +37,13 @@ def getall(current_user_id=None, subset=None):
         key = f"{turn.chore.id}-{turn.timestamp}"
         volunteers_by_key[key].append(turn.user)
 
-    data = aggregator_adapter.get_chores()
+    # FIXME: replace use of aggregator_adapter.get_chores()
+    data = chores_get_all_from(now)
 
     event_groups = []
     ts = None
     if data is not None:
-        for event in data["events"]:
+        for event in data:
             event_ts = datetime.fromtimestamp(event["when"]["timestamp"])
             event_ts_str = event_ts.strftime("%d%m%Y")
             event["time_str"] = event_ts.strftime("%H:%M")
@@ -87,6 +92,7 @@ def index_api(request, name=None):
 
     if not chores:
         return HttpResponse("No chores found", status=404, content_type="text/plain")
+
     payload = {
         "title": "Chores of this week",
         "version": "1.00",
@@ -115,9 +121,7 @@ def index(request):
 
 
 def get_chores_overview(current_user_id=None, subset=None):
-    aggregator_adapter = get_aggregator_adapter()
-    if not aggregator_adapter:
-        return None, "No aggregator configuration found"
+    now = time.time()
 
     volunteers_turns = ChoreVolunteer.objects.all()
     volunteers_by_key = defaultdict(list)
@@ -125,13 +129,13 @@ def get_chores_overview(current_user_id=None, subset=None):
         key = f"{turn.chore.id}-{turn.timestamp}"
         volunteers_by_key[key].append(turn.user)
 
-    data = aggregator_adapter.get_chores()
-    if data is None:
+    chore_events = chores_get_all_from(now)
+    if chore_events is None:
         return None, "No data available"
 
     event_groups = {}
 
-    for event in data["events"]:
+    for event in chore_events:
         event_ts = datetime.fromtimestamp(event["when"]["timestamp"])
 
         event["time_str"] = event_ts.strftime("%H:%M")
diff --git a/members/models.py b/members/models.py
index 5be1ddda..c03e6a39 100644
--- a/members/models.py
+++ b/members/models.py
@@ -146,6 +146,10 @@ def image_img(self):
         else:
             return "No images uploaded yet."
 
+    @property
+    def full_name(self):
+        return f"{self.first_name} {self.last_name}"
+
     @property
     def in_group(request, group):
         return request.user.groups.filter(name=group).exists()
diff --git a/pyproject.toml b/pyproject.toml
index 0f0f1cb0..93b2b55e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,7 +24,6 @@ dependencies = [
     "reportlab>=4.0.7,<5",
     "pypdf2>=3.0.1,<4",
     "lxml>=5.0.0,<6",
-    "jsonfield2>=4.0.0.post0,<5",
     "django-money>=3.4.0,<4",
     "requests>=2.32.2,<3",
     "python-dateutil>=2.8.2,<3",
@@ -42,6 +41,11 @@ dependencies = [
     "pycryptodome>=3.22.0",
     "django-sendmail-backend>=0.1.2",
     "django-oauth-toolkit>=3.0.1",
+    "croniter>=6.0.0",
+    "humanize>=4.12.3",
+    "time-machine>=2.16.0",
+    "factory-boy>=3.3.3",
+    "jsonfield2>=4.0.0.post0",
 ]
 
 [dependency-groups]
diff --git a/selfservice/aggregator_adapter.py b/selfservice/aggregator_adapter.py
index 09e894d9..5668c2d9 100644
--- a/selfservice/aggregator_adapter.py
+++ b/selfservice/aggregator_adapter.py
@@ -59,15 +59,6 @@ def notification_test(self, user_id):
     def checkout(self, user_id):
         self._request_with_user_id("/space/checkout", user_id)
 
-    def get_chores(self):
-        payload = self._request_with_user_id("/chores/overview")
-        if payload:
-            try:
-                return json.loads(payload)
-            except Exception:
-                logger.error("Failed to parse the json chore: '{}'.".format(payload))
-        return None
-
 
 def initialize_aggregator_adapter(base_url, username, password):
     return AggregatorAdapter(base_url, username, password)
diff --git a/selfservice/test_helpers/mocks.py b/selfservice/test_helpers/mocks.py
index 092af65c..3bb35aae 100644
--- a/selfservice/test_helpers/mocks.py
+++ b/selfservice/test_helpers/mocks.py
@@ -16,6 +16,3 @@ def notification_test(self, user_id):
 
     def checkout(self, user_id):
         pass
-
-    def get_chores(self):
-        return {"chores": ["mocked-chore-1", "mocked-chore-2"]}
diff --git a/uv.lock b/uv.lock
index a474b7ad..8febd086 100644
--- a/uv.lock
+++ b/uv.lock
@@ -178,6 +178,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b8/40/c199d095151addf69efdb4b9ca3a4f20f70e20508d6222bffb9b76f58573/constantly-23.10.4-py3-none-any.whl", hash = "sha256:3fd9b4d1c3dc1ec9757f3c52aef7e53ad9323dbe39f51dfd4c43853b68dfa3f9", size = 13547, upload-time = "2023-10-28T23:18:23.038Z" },
 ]
 
+[[package]]
+name = "croniter"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+    { name = "pytz" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ad/2f/44d1ae153a0e27be56be43465e5cb39b9650c781e001e7864389deb25090/croniter-6.0.0.tar.gz", hash = "sha256:37c504b313956114a983ece2c2b07790b1f1094fe9d81cc94739214748255577", size = 64481, upload-time = "2024-12-17T17:17:47.32Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/4b/290b4c3efd6417a8b0c284896de19b1d5855e6dbdb97d2a35e68fa42de85/croniter-6.0.0-py2.py3-none-any.whl", hash = "sha256:2f878c3856f17896979b2a4379ba1f09c83e374931ea15cc835c5dd2eee9b368", size = 25468, upload-time = "2024-12-17T17:17:45.359Z" },
+]
+
 [[package]]
 name = "cryptography"
 version = "44.0.3"
@@ -490,6 +503,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" },
 ]
 
+[[package]]
+name = "factory-boy"
+version = "3.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "faker" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/98/75cacae9945f67cfe323829fc2ac451f64517a8a330b572a06a323997065/factory_boy-3.3.3.tar.gz", hash = "sha256:866862d226128dfac7f2b4160287e899daf54f2612778327dd03d0e2cb1e3d03", size = 164146, upload-time = "2025-02-03T09:49:04.433Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/8d/2bc5f5546ff2ccb3f7de06742853483ab75bf74f36a92254702f8baecc79/factory_boy-3.3.3-py2.py3-none-any.whl", hash = "sha256:1c39e3289f7e667c4285433f305f8d506efc2fe9c73aaea4151ebd5cdea394fc", size = 37036, upload-time = "2025-02-03T09:49:01.659Z" },
+]
+
+[[package]]
+name = "faker"
+version = "37.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/65/f9/66af4019ee952fc84b8fe5b523fceb7f9e631ed8484417b6f1e3092f8290/faker-37.4.0.tar.gz", hash = "sha256:7f69d579588c23d5ce671f3fa872654ede0e67047820255f43a4aa1925b89780", size = 1901976, upload-time = "2025-06-11T17:59:30.818Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/5e/c8c3c5ea0896ab747db2e2889bf5a6f618ed291606de6513df56ad8670a8/faker-37.4.0-py3-none-any.whl", hash = "sha256:cb81c09ebe06c32a10971d1bbdb264bb0e22b59af59548f011ac4809556ce533", size = 1942992, upload-time = "2025-06-11T17:59:28.698Z" },
+]
+
 [[package]]
 name = "filelock"
 version = "3.18.0"
@@ -499,6 +536,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4d/36/2a115987e2d8c300a974597416d9de88f2444426de9571f4b59b2cca3acc/filelock-3.18.0-py3-none-any.whl", hash = "sha256:c401f4f8377c4464e6db25fff06205fd89bdd83b65eb0488ed1b160f780e21de", size = 16215, upload-time = "2025-03-14T07:11:39.145Z" },
 ]
 
+[[package]]
+name = "humanize"
+version = "4.12.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/d1/bbc4d251187a43f69844f7fd8941426549bbe4723e8ff0a7441796b0789f/humanize-4.12.3.tar.gz", hash = "sha256:8430be3a615106fdfceb0b2c1b41c4c98c6b0fc5cc59663a5539b111dd325fb0", size = 80514, upload-time = "2025-04-30T11:51:07.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/1e/62a2ec3104394a2975a2629eec89276ede9dbe717092f6966fcf963e1bf0/humanize-4.12.3-py3-none-any.whl", hash = "sha256:2cbf6370af06568fa6d2da77c86edb7886f3160ecd19ee1ffef07979efc597f6", size = 128487, upload-time = "2025-04-30T11:51:06.468Z" },
+]
+
 [[package]]
 name = "hyperlink"
 version = "21.0.0"
@@ -624,6 +670,7 @@ version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
     { name = "channels", extra = ["daphne"] },
+    { name = "croniter" },
     { name = "cryptography" },
     { name = "django" },
     { name = "django-bootstrap5" },
@@ -643,6 +690,8 @@ dependencies = [
     { name = "django-versatileimagefield" },
     { name = "djangorestframework" },
     { name = "djproxy" },
+    { name = "factory-boy" },
+    { name = "humanize" },
     { name = "jsonfield2" },
     { name = "jsonschema" },
     { name = "lxml" },
@@ -657,6 +706,7 @@ dependencies = [
     { name = "reportlab" },
     { name = "requests" },
     { name = "six" },
+    { name = "time-machine" },
     { name = "websockets" },
     { name = "wheel" },
 ]
@@ -670,6 +720,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "channels", extras = ["daphne"], specifier = ">=4.1.0,<5" },
+    { name = "croniter", specifier = ">=6.0.0" },
     { name = "cryptography", specifier = ">=44.0.3" },
     { name = "django", specifier = ">=4.2.17,<5" },
     { name = "django-bootstrap5", specifier = "~=23.4" },
@@ -689,7 +740,9 @@ requires-dist = [
     { name = "django-versatileimagefield", specifier = "~=3.0" },
     { name = "djangorestframework", specifier = ">=3.15.2,<4" },
     { name = "djproxy", specifier = ">=2.3.6,<3" },
-    { name = "jsonfield2", specifier = ">=4.0.0.post0,<5" },
+    { name = "factory-boy", specifier = ">=3.3.3" },
+    { name = "humanize", specifier = ">=4.12.3" },
+    { name = "jsonfield2", specifier = ">=4.0.0.post0" },
     { name = "jsonschema", specifier = ">=4.23.0" },
     { name = "lxml", specifier = ">=5.0.0,<6" },
     { name = "mysqlclient", specifier = ">=2.2.0,<3" },
@@ -703,6 +756,7 @@ requires-dist = [
     { name = "reportlab", specifier = ">=4.0.7,<5" },
     { name = "requests", specifier = ">=2.32.2,<3" },
     { name = "six", specifier = ">=1.16.0,<2" },
+    { name = "time-machine", specifier = ">=2.16.0" },
     { name = "websockets", specifier = "~=12.0" },
     { name = "wheel", specifier = ">=0.42.0,<0.43" },
 ]
@@ -1207,6 +1261,28 @@ yaml = [
     { name = "pyyaml" },
 ]
 
+[[package]]
+name = "time-machine"
+version = "2.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fb/dd/5022939b9cadefe3af04f4012186c29b8afbe858b1ec2cfa38baeec94dab/time_machine-2.16.0.tar.gz", hash = "sha256:4a99acc273d2f98add23a89b94d4dd9e14969c01214c8514bfa78e4e9364c7e2", size = 24626, upload-time = "2024-10-08T14:21:59.734Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/18/3087d0eb185cedbc82385f46bf16032ec7102a0e070205a2c88c4ecf9952/time_machine-2.16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7751bf745d54e9e8b358c0afa332815da9b8a6194b26d0fd62876ab6c4d5c9c0", size = 20209, upload-time = "2024-10-08T14:21:34.222Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a3/fcc3eaf69390402ecf491d718e533b6d0e06d944d77fc8d87be3a2839102/time_machine-2.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1784edf173ca840ba154de6eed000b5727f65ab92972c2f88cec5c4d6349c5f2", size = 16681, upload-time = "2024-10-08T14:21:35.14Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/96/8b76d264014bf9dc21873218de50d67223c71736f87fe6c65e582f7c29ac/time_machine-2.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f5876a5682ce1f517e55d7ace2383432627889f6f7e338b961f99d684fd9e8d", size = 33768, upload-time = "2024-10-08T14:21:36.942Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/13/59ae8259be02b6c657ef6e3b6952bf274b43849f6f35cc61a576c68ce301/time_machine-2.16.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:806672529a2e255cd901f244c9033767dc1fa53466d0d3e3e49565a1572a64fe", size = 31685, upload-time = "2024-10-08T14:21:37.881Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/c1/9f142beb4d373a2a01ebb58d5117289315baa5131d880ec804db49e94bf7/time_machine-2.16.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:667b150fedb54acdca2a4bea5bf6da837b43e6dd12857301b48191f8803ba93f", size = 33447, upload-time = "2024-10-08T14:21:38.809Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f7/ed9ecd93c2d38dca77d0a28e070020f3ce0fb23e0d4a6edb14bcfffa5526/time_machine-2.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:da3ae1028af240c0c46c79adf9c1acffecc6ed1701f2863b8132f5ceae6ae4b5", size = 33408, upload-time = "2024-10-08T14:21:39.785Z" },
+    { url = "https://files.pythonhosted.org/packages/91/40/d0d274d70fa2c4cad531745deb8c81346365beb0a2736be05a3acde8b94a/time_machine-2.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:520a814ea1b2706c89ab260a54023033d3015abef25c77873b83e3d7c1fafbb2", size = 31526, upload-time = "2024-10-08T14:21:40.769Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ba/a27cdbb324d9a6d779cde0d514d47b696b5a6a653705d4b511fd65ef1514/time_machine-2.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8243664438bb468408b29c6865958662d75e51f79c91842d2794fa22629eb697", size = 33042, upload-time = "2024-10-08T14:21:41.722Z" },
+    { url = "https://files.pythonhosted.org/packages/72/63/64e9156c9e38c18720d0cc41378168635241de44013ffe3dd5b099447eb0/time_machine-2.16.0-cp313-cp313-win32.whl", hash = "sha256:32d445ce20d25c60ab92153c073942b0bac9815bfbfd152ce3dcc225d15ce988", size = 19108, upload-time = "2024-10-08T14:21:43.596Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/40/27f5738fbd50b78dcc0682c14417eac5a49ccf430525dd0c5a058be125a2/time_machine-2.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:f6927dda86425f97ffda36131f297b1a601c64a6ee6838bfa0e6d3149c2f0d9f", size = 19935, upload-time = "2024-10-08T14:21:45.277Z" },
+    { url = "https://files.pythonhosted.org/packages/35/75/c4d8b2f0fe7dac22854d88a9c509d428e78ac4bf284bc54cfe83f75cc13b/time_machine-2.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:4d3843143c46dddca6491a954bbd0abfd435681512ac343169560e9bab504129", size = 18047, upload-time = "2024-10-08T14:21:46.261Z" },
+]
+
 [[package]]
 name = "tomlkit"
 version = "0.7.2"