diff --git a/.gitignore b/.gitignore
index f9cac8a5..e9785d14 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,4 @@ google-credentials.json
 .composer
 .deployment
 /.phpunit.cache
+.php-cs-fixer.cache
diff --git a/app/Actions/CreateUserAction.php b/app/Actions/CreateUserAction.php
index 41051055..fca87ac2 100644
--- a/app/Actions/CreateUserAction.php
+++ b/app/Actions/CreateUserAction.php
@@ -5,7 +5,6 @@
 namespace Toby\Actions;
 
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 class CreateUserAction
 {
@@ -17,19 +16,6 @@ public function execute(array $userData, array $profileData): User
 
         $user->profile()->create($profileData);
 
-        $this->createVacationLimitsFor($user);
-
         return $user;
     }
-
-    protected function createVacationLimitsFor(User $user): void
-    {
-        $yearPeriods = YearPeriod::all();
-
-        foreach ($yearPeriods as $yearPeriod) {
-            $user->vacationLimits()->create([
-                "year_period_id" => $yearPeriod->id,
-            ]);
-        }
-    }
 }
diff --git a/app/Actions/CreateYearPeriodAction.php b/app/Actions/CreateYearPeriodAction.php
deleted file mode 100644
index 3c392323..00000000
--- a/app/Actions/CreateYearPeriodAction.php
+++ /dev/null
@@ -1,53 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Toby\Actions;
-
-use Toby\Domain\PolishHolidaysRetriever;
-use Toby\Models\User;
-use Toby\Models\YearPeriod;
-
-class CreateYearPeriodAction
-{
-    public function __construct(
-        protected PolishHolidaysRetriever $polishHolidaysRetriever,
-    ) {}
-
-    public function execute(int $year): YearPeriod
-    {
-        $yearPeriod = new YearPeriod([
-            "year" => $year,
-        ]);
-
-        $yearPeriod->save();
-
-        $this->createVacationLimitsFor($yearPeriod);
-        $this->createHolidaysFor($yearPeriod);
-
-        return $yearPeriod;
-    }
-
-    protected function createVacationLimitsFor(YearPeriod $yearPeriod): void
-    {
-        $users = User::all();
-
-        foreach ($users as $user) {
-            $yearPeriod->vacationLimits()->create([
-                "user_id" => $user->id,
-            ]);
-        }
-    }
-
-    protected function createHolidaysFor(YearPeriod $yearPeriod): void
-    {
-        $holidays = $this->polishHolidaysRetriever->getForYearPeriod($yearPeriod);
-
-        foreach ($holidays as $holiday) {
-            $yearPeriod->holidays()->create([
-                "name" => $holiday["name"],
-                "date" => $holiday["date"],
-            ]);
-        }
-    }
-}
diff --git a/app/Actions/VacationRequest/CreateAction.php b/app/Actions/VacationRequest/CreateAction.php
index bc92ddc9..34441ac9 100644
--- a/app/Actions/VacationRequest/CreateAction.php
+++ b/app/Actions/VacationRequest/CreateAction.php
@@ -63,7 +63,6 @@ protected function createVacationRequest(array $data, User $creator): VacationRe
             $vacationRequest->vacations()->create([
                 "date" => $day,
                 "user_id" => $vacationRequest->user->id,
-                "year_period_id" => $vacationRequest->yearPeriod->id,
             ]);
         }
 
diff --git a/app/Console/Commands/GenerateHolidays.php b/app/Console/Commands/GenerateHolidays.php
new file mode 100644
index 00000000..eb30ea05
--- /dev/null
+++ b/app/Console/Commands/GenerateHolidays.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Toby\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Carbon;
+use Toby\Domain\PolishHolidaysRetriever;
+use Toby\Models\Holiday;
+
+class GenerateHolidays extends Command
+{
+    protected $signature = "toby:holidays:generate {year?}";
+    protected $description = "Generate default holidays for year";
+
+    public function handle(PolishHolidaysRetriever $polishHolidaysRetriever): void
+    {
+        $year = (int)$this->argument("year") ?? Carbon::now()->year;
+
+        $holidays = $polishHolidaysRetriever->getForYear($year);
+
+        foreach ($holidays as $holiday) {
+            Holiday::query()
+                ->updateOrCreate([
+                    "name" => $holiday["name"],
+                    "date" => $holiday["date"],
+                ]);
+        }
+    }
+}
diff --git a/app/Console/Commands/MigrateYearPeriodYearToVacationLimits.php b/app/Console/Commands/MigrateYearPeriodYearToVacationLimits.php
new file mode 100644
index 00000000..a1c82fe3
--- /dev/null
+++ b/app/Console/Commands/MigrateYearPeriodYearToVacationLimits.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Toby\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class MigrateYearPeriodYearToVacationLimits extends Command
+{
+    protected $signature = "toby:migrate-year-period-year-to-vacation-limits";
+    protected $description = "Migrate year period to vacation limits";
+
+    public function handle(): void
+    {
+        if (!Schema::hasTable("year_periods")) {
+            $this->error("Year periods don't exist");
+
+            return;
+        }
+
+        DB::statement("
+            UPDATE vacation_limits
+            SET year = year_periods.year
+            FROM year_periods
+            WHERE year_periods.id = vacation_limits.year_period_id
+        ");
+    }
+}
diff --git a/app/Console/Commands/RebuildDocumentNumberingSystem.php b/app/Console/Commands/RebuildDocumentNumberingSystem.php
index dd506ef7..82714a45 100644
--- a/app/Console/Commands/RebuildDocumentNumberingSystem.php
+++ b/app/Console/Commands/RebuildDocumentNumberingSystem.php
@@ -5,7 +5,8 @@
 namespace Toby\Console\Commands;
 
 use Illuminate\Console\Command;
-use Toby\Models\YearPeriod;
+use Illuminate\Support\Facades\DB;
+use Toby\Models\VacationRequest;
 
 class RebuildDocumentNumberingSystem extends Command
 {
@@ -14,18 +15,20 @@ class RebuildDocumentNumberingSystem extends Command
 
     public function handle(): void
     {
-        $yearPeriods = YearPeriod::all();
+        $years = DB::table(VacationRequest::class)
+            ->select([DB::raw("YEAR(from) as year")])
+            ->groupBy("year")
+            ->value("year");
 
-        foreach ($yearPeriods as $yearPeriod) {
+        foreach ($years as $year) {
             $number = 1;
 
-            $vacationRequests = $yearPeriod
-                ->vacationRequests()
-                ->oldest()
+            $vacationRequests = VacationRequest::query()
+                ->whereYear("date", $year)
                 ->get();
 
             foreach ($vacationRequests as $vacationRequest) {
-                $vacationRequest->update(["name" => "{$number}/{$yearPeriod->year}"]);
+                $vacationRequest->update(["name" => "{$number}/{$year}"]);
 
                 $number++;
             }
diff --git a/app/Domain/CalendarGenerator.php b/app/Domain/CalendarGenerator.php
index 4d04c395..dd106a09 100644
--- a/app/Domain/CalendarGenerator.php
+++ b/app/Domain/CalendarGenerator.php
@@ -7,23 +7,19 @@
 use Carbon\CarbonPeriod;
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Collection;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Resources\SimpleVacationRequestResource;
+use Toby\Models\Holiday;
 use Toby\Models\Vacation;
-use Toby\Models\YearPeriod;
 
 class CalendarGenerator
 {
-    public function __construct(
-        protected YearPeriodRetriever $yearPeriodRetriever,
-    ) {}
-
     public function generate(Carbon $month): array
     {
         $period = CarbonPeriod::create($month->copy()->startOfMonth(), $month->copy()->endOfMonth());
-        $yearPeriod = YearPeriod::findByYear($month->year);
 
-        $holidays = $yearPeriod->holidays()->pluck("date");
+        $holidays = Holiday::query()
+            ->whereYear("date", $month->year)
+            ->pluck("date");
 
         return $this->generateCalendar($period, $holidays);
     }
@@ -63,14 +59,4 @@ protected function getVacationsForPeriod(CarbonPeriod $period): Collection
             ->get()
             ->groupBy(fn(Vacation $vacation): string => $vacation->date->toDateString());
     }
-
-    protected function getPendingVacationsForPeriod(CarbonPeriod $period): Collection
-    {
-        return Vacation::query()
-            ->whereBetween("date", [$period->start, $period->end])
-            ->pending()
-            ->with("vacationRequest")
-            ->get()
-            ->groupBy(fn(Vacation $vacation): string => $vacation->date->toDateString());
-    }
 }
diff --git a/app/Domain/DashboardAggregator.php b/app/Domain/DashboardAggregator.php
index 67493275..f6c09a26 100644
--- a/app/Domain/DashboardAggregator.php
+++ b/app/Domain/DashboardAggregator.php
@@ -14,7 +14,7 @@
 use Toby\Models\Holiday;
 use Toby\Models\User;
 use Toby\Models\Vacation;
-use Toby\Models\YearPeriod;
+use Toby\Models\VacationRequest;
 
 class DashboardAggregator
 {
@@ -24,14 +24,16 @@ public function __construct(
         protected UserBenefitsRetriever $benefitsRetriever,
     ) {}
 
-    public function aggregateStats(User $user, YearPeriod $yearPeriod): array
+    public function aggregateStats(User $user, ?int $year = null): array
     {
-        $limit = $this->vacationStatsRetriever->getVacationDaysLimit($user, $yearPeriod);
-        $hasLimit = $this->vacationStatsRetriever->hasVacationDaysLimit($user, $yearPeriod);
-        $used = $this->vacationStatsRetriever->getUsedVacationDays($user, $yearPeriod);
-        $pending = $this->vacationStatsRetriever->getPendingVacationDays($user, $yearPeriod);
-        $remoteWork = $this->vacationStatsRetriever->getRemoteWorkDays($user, $yearPeriod);
-        $other = $this->vacationStatsRetriever->getOtherApprovedVacationDays($user, $yearPeriod);
+        $year ??= Carbon::now()->year;
+
+        $limit = $this->vacationStatsRetriever->getVacationDaysLimit($user, $year);
+        $hasLimit = $this->vacationStatsRetriever->hasVacationDaysLimit($user, $year);
+        $used = $this->vacationStatsRetriever->getUsedVacationDays($user, $year);
+        $pending = $this->vacationStatsRetriever->getPendingVacationDays($user, $year);
+        $remoteWork = $this->vacationStatsRetriever->getRemoteWorkDays($user, $year);
+        $other = $this->vacationStatsRetriever->getOtherApprovedVacationDays($user, $year);
         $remaining = $limit - $used - $pending;
 
         return [
@@ -45,12 +47,12 @@ public function aggregateStats(User $user, YearPeriod $yearPeriod): array
         ];
     }
 
-    public function aggregateCalendarData(User $user, YearPeriod $yearPeriod): array
+    public function aggregateCalendarData(User $user, ?int $year = null): array
     {
         $approvedVacations = $user
             ->vacations()
             ->with(["vacationRequest.vacations", "vacationRequest.user.profile"])
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year ?? Carbon::now()->year)
             ->cache("vacations:{$user->id}")
             ->approved()
             ->get()
@@ -63,7 +65,7 @@ public function aggregateCalendarData(User $user, YearPeriod $yearPeriod): array
         $pendingVacations = $user
             ->vacations()
             ->with(["vacationRequest.vacations", "vacationRequest.user.profile"])
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year ?? Carbon::now()->year)
             ->cache("vacations:{$user->id}")
             ->pending()
             ->get()
@@ -73,8 +75,9 @@ public function aggregateCalendarData(User $user, YearPeriod $yearPeriod): array
                 ],
             );
 
-        $holidays = $yearPeriod
-            ->holidays
+        $holidays = Holiday::query()
+            ->whereYear("date", $year)
+            ->get()
             ->mapWithKeys(fn(Holiday $holiday): array => [$holiday->date->toDateString() => $holiday->name]);
 
         return [
@@ -84,23 +87,21 @@ public function aggregateCalendarData(User $user, YearPeriod $yearPeriod): array
         ];
     }
 
-    public function aggregateVacationRequests(User $user, YearPeriod $yearPeriod): JsonResource
+    public function aggregateVacationRequests(User $user, ?int $year = null): JsonResource
     {
-        if ($user->can("listAllRequests")) {
-            $vacationRequests = $yearPeriod->vacationRequests()
-                ->with(["user", "vacations", "vacations.user", "vacations.user.profile", "user.permissions", "user.profile"])
+        $year ??= Carbon::now()->year;
+
+        $query = $user->can("listAllRequests")
+            ? VacationRequest::query()
                 ->states(VacationRequestStatesRetriever::waitingForUserActionStates($user))
-                ->latest("updated_at")
-                ->limit(3)
-                ->get();
-        } else {
-            $vacationRequests = $user->vacationRequests()
-                ->with(["user", "vacations", "vacations.user", "vacations.user.profile", "user.permissions", "user.profile"])
-                ->whereBelongsTo($yearPeriod)
-                ->latest("updated_at")
-                ->limit(3)
-                ->get();
-        }
+            : $user->vacationRequests();
+
+        $vacationRequests = $query
+            ->with(["user", "vacations", "vacations.user", "vacations.user.profile", "user.permissions", "user.profile"])
+            ->whereYear("from", $year)
+            ->latest("updated_at")
+            ->limit(3)
+            ->get();
 
         return VacationRequestResource::collection($vacationRequests);
     }
diff --git a/app/Domain/PolishHolidaysRetriever.php b/app/Domain/PolishHolidaysRetriever.php
index 858279ce..cb507f15 100644
--- a/app/Domain/PolishHolidaysRetriever.php
+++ b/app/Domain/PolishHolidaysRetriever.php
@@ -6,7 +6,6 @@
 
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Collection;
-use Toby\Models\YearPeriod;
 use Yasumi\Holiday;
 use Yasumi\Yasumi;
 
@@ -15,9 +14,9 @@ class PolishHolidaysRetriever
     protected const string PROVIDER_KEY = "Poland";
     protected const string LANG_KEY = "pl";
 
-    public function getForYearPeriod(YearPeriod $yearPeriod): Collection
+    public function getForYear(int $year): Collection
     {
-        $polishProvider = Yasumi::create(static::PROVIDER_KEY, $yearPeriod->year);
+        $polishProvider = Yasumi::create(static::PROVIDER_KEY, $year);
 
         $holidays = $polishProvider->getHolidays();
 
diff --git a/app/Domain/UnavailableDaysRetriever.php b/app/Domain/UnavailableDaysRetriever.php
index a896a56e..70c2b2d4 100644
--- a/app/Domain/UnavailableDaysRetriever.php
+++ b/app/Domain/UnavailableDaysRetriever.php
@@ -5,10 +5,11 @@
 namespace Toby\Domain;
 
 use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Carbon;
 use Illuminate\Support\Collection;
 use Toby\Enums\VacationType;
+use Toby\Models\Holiday;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 class UnavailableDaysRetriever
 {
@@ -17,10 +18,12 @@ public function __construct(
         protected VacationTypeConfigRetriever $configRetriever,
     ) {}
 
-    public function getUnavailableDays(User $user, YearPeriod $yearPeriod, ?VacationType $vacationType = null): Collection
+    public function getUnavailableDays(User $user, ?int $year = null, ?VacationType $vacationType = null): Collection
     {
+        $year ??= Carbon::now()->year;
+
         $unavailableDays = $user->vacations()
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->whereRelation(
                 "vacationRequest",
                 fn(Builder $query): Builder => $query->noStates(VacationRequestStatesRetriever::failedStates()),
@@ -28,8 +31,8 @@ public function getUnavailableDays(User $user, YearPeriod $yearPeriod, ?Vacation
             ->pluck("date");
 
         if (!$vacationType || !$this->configRetriever->isDuringNonWorkDays($vacationType)) {
-            $unavailableDays->push(...$yearPeriod->weekends());
-            $unavailableDays->push(...$yearPeriod->holidays()->pluck("date"));
+            $unavailableDays->push(...$this->getWeekends($year));
+            $unavailableDays->push(...$this->getHolidays($year));
         }
 
         return $unavailableDays
@@ -37,4 +40,29 @@ public function getUnavailableDays(User $user, YearPeriod $yearPeriod, ?Vacation
             ->sort()
             ->values();
     }
+
+    protected function getWeekends(int $year): Collection
+    {
+        $start = Carbon::create($year);
+        $end = Carbon::create($year)->endOfYear();
+
+        $weekends = new Collection();
+
+        while ($start->lessThanOrEqualTo($end)) {
+            if ($start->isWeekend()) {
+                $weekends->push($start->copy());
+            }
+
+            $start->addDay();
+        }
+
+        return $weekends;
+    }
+
+    protected function getHolidays(int $year): Collection
+    {
+        return Holiday::query()
+            ->whereYear("date", $year)
+            ->pluck("date");
+    }
 }
diff --git a/app/Domain/UserVacationStatsRetriever.php b/app/Domain/UserVacationStatsRetriever.php
index 2f666b6b..dc060653 100644
--- a/app/Domain/UserVacationStatsRetriever.php
+++ b/app/Domain/UserVacationStatsRetriever.php
@@ -5,11 +5,11 @@
 namespace Toby\Domain;
 
 use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Carbon;
 use Illuminate\Support\Collection;
 use Toby\Enums\VacationType;
 use Toby\Models\User;
 use Toby\Models\Vacation;
-use Toby\Models\YearPeriod;
 
 class UserVacationStatsRetriever
 {
@@ -17,11 +17,11 @@ public function __construct(
         protected VacationTypeConfigRetriever $configRetriever,
     ) {}
 
-    public function getUsedVacationDays(User $user, YearPeriod $yearPeriod): int
+    public function getUsedVacationDays(User $user, ?int $year = null): int
     {
         return $user
             ->vacations()
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->whereRelation(
                 "vacationRequest",
                 fn(Builder $query): Builder => $query
@@ -31,10 +31,10 @@ public function getUsedVacationDays(User $user, YearPeriod $yearPeriod): int
             ->count();
     }
 
-    public function getUsedVacationDaysByMonth(User $user, YearPeriod $yearPeriod): Collection
+    public function getUsedVacationDaysByMonth(User $user, ?int $year = null): Collection
     {
         return $user->vacations()
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->whereRelation(
                 "vacationRequest",
                 fn(Builder $query): Builder => $query
@@ -46,11 +46,11 @@ public function getUsedVacationDaysByMonth(User $user, YearPeriod $yearPeriod):
             ->map(fn(Collection $items): int => $items->count());
     }
 
-    public function getPendingVacationDays(User $user, YearPeriod $yearPeriod): int
+    public function getPendingVacationDays(User $user, ?int $year = null): int
     {
         return $user
             ->vacations()
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->whereRelation(
                 "vacationRequest",
                 fn(Builder $query): Builder => $query
@@ -60,11 +60,11 @@ public function getPendingVacationDays(User $user, YearPeriod $yearPeriod): int
             ->count();
     }
 
-    public function getOtherApprovedVacationDays(User $user, YearPeriod $yearPeriod): int
+    public function getOtherApprovedVacationDays(User $user, ?int $year = null): int
     {
         return $user
             ->vacations()
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->whereRelation(
                 "vacationRequest",
                 fn(Builder $query): Builder => $query
@@ -76,11 +76,11 @@ public function getOtherApprovedVacationDays(User $user, YearPeriod $yearPeriod)
             ->count();
     }
 
-    public function getRemoteWorkDays(User $user, YearPeriod $yearPeriod): int
+    public function getRemoteWorkDays(User $user, ?int $year = null): int
     {
         return $user
             ->vacations()
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->whereRelation(
                 "vacationRequest",
                 fn(Builder $query): Builder => $query
@@ -90,27 +90,27 @@ public function getRemoteWorkDays(User $user, YearPeriod $yearPeriod): int
             ->count();
     }
 
-    public function getRemainingVacationDays(User $user, YearPeriod $yearPeriod): int
+    public function getRemainingVacationDays(User $user, ?int $year = null): int
     {
-        $limit = $this->getVacationDaysLimit($user, $yearPeriod);
-        $used = $this->getUsedVacationDays($user, $yearPeriod);
-        $pending = $this->getPendingVacationDays($user, $yearPeriod);
+        $limit = $this->getVacationDaysLimit($user, $year);
+        $used = $this->getUsedVacationDays($user, $year);
+        $pending = $this->getPendingVacationDays($user, $year);
 
         return $limit - $used - $pending;
     }
 
-    public function getVacationDaysLimit(User $user, YearPeriod $yearPeriod): int
+    public function getVacationDaysLimit(User $user, ?int $year = null): int
     {
         return $user->vacationLimits()
-            ->whereBelongsTo($yearPeriod)
+            ->where("year", $year ?? Carbon::today()->year)
             ->cache("vacations:{$user->id}")
             ->first()?->limit ?? 0;
     }
 
-    public function hasVacationDaysLimit(User $user, YearPeriod $yearPeriod): bool
+    public function hasVacationDaysLimit(User $user, ?int $year = null): bool
     {
         return $user->vacationLimits()
-            ->whereBelongsTo($yearPeriod)
+            ->where("year", $year ?? Carbon::today()->year)
             ->cache("vacations:{$user->id}")
             ->first()?->hasVacation() ?? false;
     }
diff --git a/app/Domain/WorkDaysCalculator.php b/app/Domain/WorkDaysCalculator.php
index 1363d81f..c9fd44f9 100644
--- a/app/Domain/WorkDaysCalculator.php
+++ b/app/Domain/WorkDaysCalculator.php
@@ -8,7 +8,7 @@
 use Carbon\CarbonPeriod;
 use Illuminate\Support\Collection;
 use Toby\Enums\VacationType;
-use Toby\Models\YearPeriod;
+use Toby\Models\Holiday;
 
 class WorkDaysCalculator
 {
@@ -19,8 +19,7 @@ public function __construct(
     public function calculateDays(CarbonInterface $from, CarbonInterface $to, ?VacationType $vacationType = null): Collection
     {
         $period = CarbonPeriod::create($from, $to);
-        $yearPeriod = YearPeriod::findByYear($from->year);
-        $holidays = $yearPeriod->holidays()->pluck("date");
+        $holidays = $this->getHolidays($from->year);
 
         $validDays = new Collection();
 
@@ -49,4 +48,11 @@ protected function passes(CarbonInterface $day, Collection $holidays, ?VacationT
 
         return true;
     }
+
+    protected function getHolidays(int $year): Collection
+    {
+        return Holiday::query()
+            ->whereYear("date", $year)
+            ->pluck("date");
+    }
 }
diff --git a/app/Helpers/YearPeriodRetriever.php b/app/Helpers/YearPeriodRetriever.php
deleted file mode 100644
index a9b04e60..00000000
--- a/app/Helpers/YearPeriodRetriever.php
+++ /dev/null
@@ -1,54 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Toby\Helpers;
-
-use Illuminate\Contracts\Session\Session;
-use Toby\Models\YearPeriod;
-
-class YearPeriodRetriever
-{
-    public const string SESSION_KEY = "selected_year_period";
-
-    public function __construct(
-        protected Session $session,
-    ) {}
-
-    public function selected(): YearPeriod
-    {
-        /** @var YearPeriod $yearPeriod */
-        $yearPeriod = YearPeriod::query()->find($this->session->get(static::SESSION_KEY));
-
-        return $yearPeriod !== null ? $yearPeriod : $this->current();
-    }
-
-    public function current(): YearPeriod
-    {
-        return YearPeriod::current();
-    }
-
-    public function links(): array
-    {
-        $selected = $this->selected();
-        $current = $this->current();
-
-        $years = YearPeriod::query()->cache()->get();
-
-        $navigation = $years->map(fn(YearPeriod $yearPeriod): array => $this->toNavigation($yearPeriod));
-
-        return [
-            "current" => $this->toNavigation($current),
-            "selected" => $this->toNavigation($selected),
-            "navigation" => $navigation->toArray(),
-        ];
-    }
-
-    protected function toNavigation(YearPeriod $yearPeriod): array
-    {
-        return [
-            "year" => $yearPeriod->year,
-            "link" => route("year-periods.select", $yearPeriod->id),
-        ];
-    }
-}
diff --git a/app/Http/Controllers/AnnualSummaryController.php b/app/Http/Controllers/AnnualSummaryController.php
index 6100e71c..2278fa6d 100644
--- a/app/Http/Controllers/AnnualSummaryController.php
+++ b/app/Http/Controllers/AnnualSummaryController.php
@@ -5,36 +5,38 @@
 namespace Toby\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
 use Inertia\Response;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Resources\SimpleVacationRequestResource;
 use Toby\Models\Holiday;
 use Toby\Models\Vacation;
 
 class AnnualSummaryController extends Controller
 {
-    public function __invoke(Request $request, YearPeriodRetriever $yearPeriodRetriever): Response
+    public function __invoke(Request $request): Response
     {
-        $yearPeriod = $yearPeriodRetriever->selected();
+        $year = $request->integer("year", Carbon::now()->year);
 
-        $holidays = $yearPeriod->holidays()
+        $holidays = Holiday::query()
+            ->whereYear("date", $year)
             ->get();
 
         $vacations = $request->user()
             ->vacations()
             ->with("vacationRequest.vacations")
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->approved()
             ->get();
 
         $pendingVacations = $request->user()
             ->vacations()
             ->with("vacationRequest.vacations")
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->pending()
             ->get();
 
         return inertia("AnnualSummary", [
+            "year" => $year,
             "holidays" => $holidays->mapWithKeys(
                 fn(Holiday $holiday): array => [$holiday->date->toDateString() => $holiday->name],
             ),
diff --git a/app/Http/Controllers/Api/CalculateUserUnavailableDaysController.php b/app/Http/Controllers/Api/CalculateUserUnavailableDaysController.php
index 31cbf642..9442c8f6 100644
--- a/app/Http/Controllers/Api/CalculateUserUnavailableDaysController.php
+++ b/app/Http/Controllers/Api/CalculateUserUnavailableDaysController.php
@@ -8,7 +8,6 @@
 use Illuminate\Support\Carbon;
 use Toby\Domain\UnavailableDaysRetriever;
 use Toby\Domain\UserVacationStatsRetriever;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Controllers\Controller;
 use Toby\Http\Requests\Api\CalculateUserUnavailableDaysRequest;
 use Toby\Models\User;
@@ -18,14 +17,13 @@ class CalculateUserUnavailableDaysController extends Controller
     public function __invoke(
         CalculateUserUnavailableDaysRequest $request,
         UserVacationStatsRetriever $vacationStatsRetriever,
-        YearPeriodRetriever $yearPeriodRetriever,
         UnavailableDaysRetriever $unavailableDaysRetriever,
     ): JsonResponse {
         /** @var User $user */
         $user = User::query()->find($request->get("user"));
-        $yearPeriod = $yearPeriodRetriever->selected();
+        $year = $request->getYear();
 
-        $unavailableDays = $unavailableDaysRetriever->getUnavailableDays($user, $yearPeriod, $request->vacationType())
+        $unavailableDays = $unavailableDaysRetriever->getUnavailableDays($user, $year, $request->vacationType())
             ->map(fn(Carbon $date): string => $date->toDateString())
             ->toArray();
 
diff --git a/app/Http/Controllers/Api/CalculateUserVacationStatsController.php b/app/Http/Controllers/Api/CalculateUserVacationStatsController.php
index 88bfe710..ec013b30 100644
--- a/app/Http/Controllers/Api/CalculateUserVacationStatsController.php
+++ b/app/Http/Controllers/Api/CalculateUserVacationStatsController.php
@@ -6,7 +6,6 @@
 
 use Illuminate\Http\JsonResponse;
 use Toby\Domain\UserVacationStatsRetriever;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Controllers\Controller;
 use Toby\Http\Requests\Api\CalculateVacationStatsRequest;
 use Toby\Models\User;
@@ -16,16 +15,15 @@ class CalculateUserVacationStatsController extends Controller
     public function __invoke(
         CalculateVacationStatsRequest $request,
         UserVacationStatsRetriever $vacationStatsRetriever,
-        YearPeriodRetriever $yearPeriodRetriever,
     ): JsonResponse {
         /** @var User $user */
         $user = User::query()->find($request->get("user"));
-        $yearPeriod = $yearPeriodRetriever->selected();
+        $year = $request->getYear();
 
-        $limit = $vacationStatsRetriever->getVacationDaysLimit($user, $yearPeriod);
-        $used = $vacationStatsRetriever->getUsedVacationDays($user, $yearPeriod);
-        $pending = $vacationStatsRetriever->getPendingVacationDays($user, $yearPeriod);
-        $other = $vacationStatsRetriever->getOtherApprovedVacationDays($user, $yearPeriod);
+        $limit = $vacationStatsRetriever->getVacationDaysLimit($user, $year);
+        $used = $vacationStatsRetriever->getUsedVacationDays($user, $year);
+        $pending = $vacationStatsRetriever->getPendingVacationDays($user, $year);
+        $other = $vacationStatsRetriever->getOtherApprovedVacationDays($user, $year);
         $remaining = $limit - $used - $pending;
 
         return new JsonResponse([
diff --git a/app/Http/Controllers/DashboardController.php b/app/Http/Controllers/DashboardController.php
index 6798a49c..23cf14a5 100644
--- a/app/Http/Controllers/DashboardController.php
+++ b/app/Http/Controllers/DashboardController.php
@@ -5,33 +5,32 @@
 namespace Toby\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
 use Inertia\Response;
 use Toby\Domain\DailySummaryRetriever;
 use Toby\Domain\DashboardAggregator;
 use Toby\Domain\UserVacationStatsRetriever;
 use Toby\Domain\VacationTypeConfigRetriever;
-use Toby\Helpers\YearPeriodRetriever;
 
 class DashboardController extends Controller
 {
     public function __invoke(
         Request $request,
-        YearPeriodRetriever $yearPeriodRetriever,
         UserVacationStatsRetriever $vacationStatsRetriever,
         VacationTypeConfigRetriever $configRetriever,
         DailySummaryRetriever $dailySummaryRetriever,
         DashboardAggregator $dashboardAggregator,
     ): Response {
         $user = $request->user();
-        $yearPeriod = $yearPeriodRetriever->selected();
+        $year = Carbon::now()->year;
 
         return inertia("Dashboard", [
             "current" => $dashboardAggregator->aggregateCurrentData(),
             "upcoming" => $dashboardAggregator->aggregateUpcomingData(),
-            "vacationRequests" => $dashboardAggregator->aggregateVacationRequests($user, $yearPeriod),
+            "vacationRequests" => $dashboardAggregator->aggregateVacationRequests($user, $year),
             "benefits" => $dashboardAggregator->aggregateUserBenefits($user),
-            "calendar" => $dashboardAggregator->aggregateCalendarData($user, $yearPeriod),
-            "stats" => $dashboardAggregator->aggregateStats($user, $yearPeriod),
+            "calendar" => $dashboardAggregator->aggregateCalendarData($user, $year),
+            "stats" => $dashboardAggregator->aggregateStats($user, $year),
         ]);
     }
 }
diff --git a/app/Http/Controllers/HolidayController.php b/app/Http/Controllers/HolidayController.php
index 94cb60c1..968f0829 100644
--- a/app/Http/Controllers/HolidayController.php
+++ b/app/Http/Controllers/HolidayController.php
@@ -7,8 +7,8 @@
 use Illuminate\Auth\Access\AuthorizationException;
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
 use Inertia\Response;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Requests\HolidayRequest;
 use Toby\Http\Resources\HolidayFormDataResource;
 use Toby\Http\Resources\HolidayResource;
@@ -16,17 +16,18 @@
 
 class HolidayController extends Controller
 {
-    public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever): Response
+    public function index(Request $request): Response
     {
-        $yearPeriod = $yearPeriodRetriever->selected();
+        $year = $request->integer("year", Carbon::now()->year);
 
-        $holidays = $yearPeriod
-            ->holidays()
+        $holidays = Holiday::query()
+            ->whereYear("date", $year)
             ->orderBy("date")
             ->get();
 
         return inertia("Holidays/Index", [
             "holidays" => HolidayResource::collection($holidays),
+            "year" => $year,
         ]);
     }
 
diff --git a/app/Http/Controllers/MonthlyUsageController.php b/app/Http/Controllers/MonthlyUsageController.php
index de62e046..5e572d7b 100644
--- a/app/Http/Controllers/MonthlyUsageController.php
+++ b/app/Http/Controllers/MonthlyUsageController.php
@@ -5,10 +5,10 @@
 namespace Toby\Http\Controllers;
 
 use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
 use Inertia\Response;
 use Toby\Domain\UserVacationStatsRetriever;
 use Toby\Enums\Month;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Resources\SimpleUserResource;
 use Toby\Models\User;
 
@@ -16,33 +16,32 @@ class MonthlyUsageController extends Controller
 {
     public function __invoke(
         Request $request,
-        YearPeriodRetriever $yearPeriodRetriever,
         UserVacationStatsRetriever $statsRetriever,
     ): Response {
         $this->authorize("listMonthlyUsage");
 
-        $currentYearPeriod = $yearPeriodRetriever->selected();
+        $year = $request->integer("year", Carbon::now()->year);
         $currentUser = $request->user();
 
         $users = User::query()
             ->withTrashed($currentUser->canSeeInactiveUsers())
-            ->withVacationLimitIn($currentYearPeriod)
+            ->withVacationLimitIn($year)
             ->where("id", "!=", $currentUser->id)
             ->orderByProfileField("last_name")
             ->orderByProfileField("first_name")
             ->get();
 
-        if ($currentUser->hasVacationLimit($currentYearPeriod)) {
+        if ($currentUser->hasVacationLimit($year)) {
             $users->prepend($currentUser);
         }
 
         $monthlyUsage = [];
 
         foreach ($users as $user) {
-            $vacationsByMonth = $statsRetriever->getUsedVacationDaysByMonth($user, $currentYearPeriod);
-            $limit = $statsRetriever->getVacationDaysLimit($user, $currentYearPeriod);
-            $used = $statsRetriever->getUsedVacationDays($user, $currentYearPeriod);
-            $pending = $statsRetriever->getPendingVacationDays($user, $currentYearPeriod);
+            $vacationsByMonth = $statsRetriever->getUsedVacationDaysByMonth($user, $year);
+            $limit = $statsRetriever->getVacationDaysLimit($user, $year);
+            $used = $statsRetriever->getUsedVacationDays($user, $year);
+            $pending = $statsRetriever->getPendingVacationDays($user, $year);
             $remaining = $limit - $used - $pending;
 
             $monthlyUsage[] = [
@@ -57,6 +56,7 @@ public function __invoke(
         }
 
         return inertia("MonthlyUsage", [
+            "year" => $year,
             "monthlyUsage" => $monthlyUsage,
             "currentMonth" => Month::current(),
         ]);
diff --git a/app/Http/Controllers/OvertimeRequestController.php b/app/Http/Controllers/OvertimeRequestController.php
index ec3c8dde..9274c666 100644
--- a/app/Http/Controllers/OvertimeRequestController.php
+++ b/app/Http/Controllers/OvertimeRequestController.php
@@ -8,6 +8,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
 use Inertia\Response;
 use Toby\Actions\OvertimeRequest\AcceptAsTechnicalAction;
 use Toby\Actions\OvertimeRequest\CancelAction;
@@ -16,7 +17,6 @@
 use Toby\Actions\OvertimeRequest\SettleAction;
 use Toby\Domain\OvertimeRequestStatesRetriever;
 use Toby\Enums\SettlementType;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Requests\OvertimeRequestRequest;
 use Toby\Http\Resources\OvertimeRequestActivityResource;
 use Toby\Http\Resources\OvertimeRequestResource;
@@ -26,48 +26,50 @@
 
 class OvertimeRequestController extends Controller
 {
-    public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever): RedirectResponse|Response
+    public function index(Request $request): RedirectResponse|Response
     {
         if ($request->user()->can("listAllOvertimeRequests")) {
             return redirect()->route("overtime.requests.indexForApprovers");
         }
+
         $user = $request->user();
         $this->authorize("canUseOvertimeRequestFunctionality", $user);
 
         $status = $request->get("status", "all");
+        $year = $request->integer("year", Carbon::now()->year);
 
         $overtimeRequests = $user
             ->overtimeRequests()
+            ->whereYear("from", $year)
             ->with(["user.permissions", "user.profile"])
-            ->whereBelongsTo($yearPeriodRetriever->selected())
             ->latest()
             ->states(OvertimeRequestStatesRetriever::filterByStatusGroup($status, $request->user()))
             ->paginate();
 
         $pending = $user
             ->overtimeRequests()
-            ->whereBelongsTo($yearPeriodRetriever->selected())
+            ->whereYear("from", $year)
             ->states(OvertimeRequestStatesRetriever::pendingStates())
             ->cache(key: "overtime:{$user->id}")
             ->count();
 
         $success = $user
             ->overtimeRequests()
-            ->whereBelongsTo($yearPeriodRetriever->selected())
+            ->whereYear("from", $year)
             ->states(OvertimeRequestStatesRetriever::successStates())
             ->cache(key: "overtime:{$user->id}")
             ->count();
 
         $failed = $user
             ->overtimeRequests()
-            ->whereBelongsTo($yearPeriodRetriever->selected())
+            ->whereYear("from", $year)
             ->states(OvertimeRequestStatesRetriever::failedStates())
             ->cache(key: "overtime:{$user->id}")
             ->count();
 
         $settled = $user
             ->overtimeRequests()
-            ->whereBelongsTo($yearPeriodRetriever->selected())
+            ->whereYear("from", $year)
             ->states(OvertimeRequestStatesRetriever::settledStates())
             ->cache(key: "overtime:{$user->id}")
             ->count();
@@ -83,29 +85,30 @@ public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever
             ],
             "filters" => [
                 "status" => $status,
+                "year" => $year,
             ],
         ]);
     }
 
     public function indexForApprovers(
         Request $request,
-        YearPeriodRetriever $yearPeriodRetriever,
     ): RedirectResponse|Response {
         if ($request->user()->cannot("listAllOvertimeRequests")) {
             abort(403);
         }
 
-        $yearPeriod = $yearPeriodRetriever->selected();
         $status = $request->get("status", "all");
         $user = $request->get("user");
+        $year = $request->get("year");
+
         $authUser = $request->user();
         $withTrashedUsers = $authUser->canSeeInactiveUsers();
 
         $overtimeRequests = OvertimeRequest::query()
             ->with(["user.permissions", "user.profile"])
-            ->whereBelongsTo($yearPeriod)
             ->whereRelation("user", fn(Builder $query): Builder => $query->withTrashed($withTrashedUsers))
             ->when($user !== null, fn(Builder $query): Builder => $query->where("user_id", $user))
+            ->when($year !== null, fn(Builder $query): Builder => $query->whereYear("from", $year))
             ->states(OvertimeRequestStatesRetriever::filterByStatusGroup($status, $authUser))
             ->latest()
             ->paginate();
@@ -122,6 +125,7 @@ public function indexForApprovers(
             "filters" => [
                 "status" => $status,
                 "user" => (int)$user,
+                "year" => $year === null ? $year : (int)$year,
             ],
         ]);
     }
diff --git a/app/Http/Controllers/OvertimeTimesheetController.php b/app/Http/Controllers/OvertimeTimesheetController.php
index 108b4b10..616f2e06 100644
--- a/app/Http/Controllers/OvertimeTimesheetController.php
+++ b/app/Http/Controllers/OvertimeTimesheetController.php
@@ -9,20 +9,17 @@
 use Symfony\Component\HttpFoundation\BinaryFileResponse;
 use Toby\Domain\OvertimeTimesheetExport;
 use Toby\Enums\EmploymentForm;
-use Toby\Enums\Month;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Models\User;
 
 class OvertimeTimesheetController extends Controller
 {
-    public function __invoke(
-        Month $month,
-        YearPeriodRetriever $yearPeriodRetriever,
-    ): BinaryFileResponse {
+    public function __invoke(?string $month = null): BinaryFileResponse
+    {
         $this->authorize("manageRequestsAsAdministrativeApprover");
 
-        $yearPeriod = $yearPeriodRetriever->selected();
-        $carbonMonth = Carbon::create($yearPeriod->year, $month->toCarbonNumber());
+        $month = Carbon::canBeCreatedFromFormat($month, "m-Y")
+            ? Carbon::createFromFormat("m-Y", $month)
+            : Carbon::now();
 
         $users = User::query()
             ->whereRelation("profile", "employment_form", EmploymentForm::EmploymentContract)
@@ -30,10 +27,10 @@ public function __invoke(
             ->orderByProfileField("first_name")
             ->get();
 
-        $filename = "overtime-{$carbonMonth->translatedFormat("F Y")}.xlsx";
+        $filename = "overtime-{$month->translatedFormat("F Y")}.xlsx";
 
         $timesheet = (new OvertimeTimesheetExport())
-            ->forMonth($carbonMonth)
+            ->forMonth($month)
             ->forUsers($users);
 
         return Excel::download($timesheet, $filename);
diff --git a/app/Http/Controllers/SelectYearPeriodController.php b/app/Http/Controllers/SelectYearPeriodController.php
deleted file mode 100644
index b35c08a2..00000000
--- a/app/Http/Controllers/SelectYearPeriodController.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Toby\Http\Controllers;
-
-use Illuminate\Http\RedirectResponse;
-use Illuminate\Http\Request;
-use Toby\Helpers\YearPeriodRetriever;
-use Toby\Models\YearPeriod;
-
-class SelectYearPeriodController extends Controller
-{
-    public function __invoke(Request $request, YearPeriod $yearPeriod): RedirectResponse
-    {
-        $request->session()->put(YearPeriodRetriever::SESSION_KEY, $yearPeriod->id);
-
-        return redirect()
-            ->back()
-            ->with("info", __("Selected year period changed."));
-    }
-}
diff --git a/app/Http/Controllers/TimesheetController.php b/app/Http/Controllers/TimesheetController.php
index f78f0745..a1956238 100644
--- a/app/Http/Controllers/TimesheetController.php
+++ b/app/Http/Controllers/TimesheetController.php
@@ -10,22 +10,18 @@
 use Toby\Domain\TimesheetExport;
 use Toby\Domain\VacationTypeConfigRetriever;
 use Toby\Enums\EmploymentForm;
-use Toby\Enums\Month;
 use Toby\Enums\VacationType;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Models\User;
 
 class TimesheetController extends Controller
 {
-    public function __invoke(
-        Month $month,
-        YearPeriodRetriever $yearPeriodRetriever,
-        VacationTypeConfigRetriever $configRetriever,
-    ): BinaryFileResponse {
+    public function __invoke(VacationTypeConfigRetriever $configRetriever, ?string $month = null): BinaryFileResponse
+    {
         $this->authorize("manageRequestsAsAdministrativeApprover");
 
-        $yearPeriod = $yearPeriodRetriever->selected();
-        $carbonMonth = Carbon::create($yearPeriod->year, $month->toCarbonNumber());
+        $month = Carbon::canBeCreatedFromFormat($month, "m-Y")
+            ? Carbon::createFromFormat("m-Y", $month)
+            : Carbon::now();
 
         $users = User::query()
             ->whereRelation("profile", "employment_form", EmploymentForm::EmploymentContract)
@@ -41,10 +37,10 @@ public function __invoke(
                 ) && $configRetriever->isVacation($type),
             );
 
-        $filename = "{$carbonMonth->translatedFormat("F Y")}.xlsx";
+        $filename = "{$month->translatedFormat("F Y")}.xlsx";
 
         $timesheet = (new TimesheetExport())
-            ->forMonth($carbonMonth)
+            ->forMonth($month)
             ->forUsers($users)
             ->forVacationTypes($types);
 
diff --git a/app/Http/Controllers/UserController.php b/app/Http/Controllers/UserController.php
index 529226a9..05776d0b 100644
--- a/app/Http/Controllers/UserController.php
+++ b/app/Http/Controllers/UserController.php
@@ -7,6 +7,7 @@
 use Illuminate\Auth\Access\AuthorizationException;
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
 use Inertia\Response;
 use Toby\Actions\CreateUserAction;
 use Toby\Actions\SyncUserPermissionsWithRoleAction;
@@ -14,7 +15,6 @@
 use Toby\Domain\DashboardAggregator;
 use Toby\Enums\EmploymentForm;
 use Toby\Enums\Role;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Requests\UserRequest;
 use Toby\Http\Resources\BirthdayResource;
 use Toby\Http\Resources\EquipmentItemResource;
@@ -152,12 +152,11 @@ public function restore(User $user): RedirectResponse
 
     public function show(
         User $user,
-        YearPeriodRetriever $yearPeriodRetriever,
         DashboardAggregator $dashboardAggregator,
     ): Response {
         $this->authorize("manageUsers");
 
-        $yearPeriod = $yearPeriodRetriever->selected();
+        $year = Carbon::now()->year;
         $equipment = EquipmentItem::query()
             ->with("assignee")
             ->where("assignee_id", $user->id)
@@ -165,13 +164,13 @@ public function show(
             ->get();
         $vacationRequests = $user->vacationRequests()
             ->with(["user", "vacations", "vacations.user", "vacations.user.profile", "user.permissions", "user.profile"])
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("from", $year)
             ->latest("updated_at")
             ->limit(2)
             ->get();
         $overtimeRequests = $user->overtimeRequests()
             ->with(["user", "user.profile", "user.permissions"])
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("from", $year)
             ->latest("updated_at")
             ->limit(2)
             ->get();
@@ -181,8 +180,8 @@ public function show(
             "vacationRequests" => VacationRequestResource::collection($vacationRequests),
             "overtimeRequests" => OvertimeRequestResource::collection($overtimeRequests),
             "benefits" => $dashboardAggregator->aggregateUserBenefits($user),
-            "calendar" => $dashboardAggregator->aggregateCalendarData($user, $yearPeriod),
-            "stats" => $dashboardAggregator->aggregateStats($user, $yearPeriod),
+            "calendar" => $dashboardAggregator->aggregateCalendarData($user, $year),
+            "stats" => $dashboardAggregator->aggregateStats($user, $year),
             "equipmentItems" => EquipmentItemResource::collection($equipment),
             "upcomingBirthday" => new BirthdayResource($user),
             "seniority" => $user->seniority(),
diff --git a/app/Http/Controllers/VacationCalendarController.php b/app/Http/Controllers/VacationCalendarController.php
index 67f404b8..0a7e8cb1 100644
--- a/app/Http/Controllers/VacationCalendarController.php
+++ b/app/Http/Controllers/VacationCalendarController.php
@@ -10,42 +10,25 @@
 use Inertia\Response;
 use Toby\Domain\CalendarGenerator;
 use Toby\Domain\MonthWorkingHoursCalculator;
-use Toby\Enums\Month;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Resources\SimpleUserResource;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 class VacationCalendarController extends Controller
 {
     public function index(
         Request $request,
-        YearPeriodRetriever $yearPeriodRetriever,
         CalendarGenerator $calendarGenerator,
         MonthWorkingHoursCalculator $monthWorkingHoursCalculator,
         ?string $month = null,
-        ?int $year = null,
     ): Response|RedirectResponse {
-        if ($year !== null) {
-            return $this->changeYearPeriod($request, $month, $year);
-        }
+        $month = Carbon::canBeCreatedFromFormat($month, "m-Y")
+            ? Carbon::createFromFormat("m-Y", $month)
+            : Carbon::now();
 
-        $month = Month::fromNameOrCurrent((string)$month);
         /** @var User $currentUser */
         $currentUser = $request->user();
         $withTrashedUsers = $currentUser->canSeeInactiveUsers();
 
-        $yearPeriod = $yearPeriodRetriever->selected();
-        $previousYearPeriod = YearPeriod::query()
-            ->where("year", "<", $yearPeriod->year)
-            ->orderBy("year", "desc")
-            ->first();
-        $nextYearPeriod = YearPeriod::query()
-            ->where("year", ">", $yearPeriod->year)
-            ->orderBy("year")
-            ->first();
-        $carbonMonth = Carbon::create($yearPeriod->year, $month->toCarbonNumber());
-
         $users = User::query()
             ->withTrashed($withTrashedUsers)
             ->where("id", "!=", $currentUser->id)
@@ -55,7 +38,7 @@ public function index(
 
         $users->prepend($currentUser);
 
-        $calendar = $calendarGenerator->generate($carbonMonth);
+        $calendar = $calendarGenerator->generate($month);
         $workingHours = $currentUser->isEmployedOnEmploymentForm()
             ? $monthWorkingHoursCalculator->calculateHours($calendar, $currentUser) * config("toby.number_of_hours_on_employment_contract.full_time")
             : null;
@@ -63,28 +46,9 @@ public function index(
         return inertia("Calendar", [
             "calendar" => $calendar,
             "workingHours" => $workingHours,
-            "currentMonth" => Month::current(),
-            "currentYear" => Carbon::now()->year,
-            "selectedMonth" => $month->value,
-            "selectedYear" => $yearPeriod->year,
+            "selectedDate" => $month->toDateString(),
             "users" => SimpleUserResource::collection($users),
             "withBlockedUsers" => $withTrashedUsers,
-            "previousYearPeriod" => $previousYearPeriod,
-            "nextYearPeriod" => $nextYearPeriod,
         ]);
     }
-
-    private function changeYearPeriod(Request $request, string $month, int $year): RedirectResponse
-    {
-        $yearPeriod = YearPeriod::query()->where("year", $year)->firstOrFail();
-
-        if ($yearPeriod->id !== $request->session()->get(YearPeriodRetriever::SESSION_KEY)) {
-            $request->session()->put(YearPeriodRetriever::SESSION_KEY, $yearPeriod->id);
-
-            return redirect()->route("calendar", ["month" => $month])
-                ->with("info", __("Year period changed."));
-        }
-
-        return redirect()->route("calendar", ["month" => $month]);
-    }
 }
diff --git a/app/Http/Controllers/VacationLimitController.php b/app/Http/Controllers/VacationLimitController.php
index 9434aca0..f24c1a1e 100644
--- a/app/Http/Controllers/VacationLimitController.php
+++ b/app/Http/Controllers/VacationLimitController.php
@@ -4,54 +4,49 @@
 
 namespace Toby\Http\Controllers;
 
-use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
+use Illuminate\Support\Carbon;
 use Inertia\Response;
 use Toby\Domain\UserVacationStatsRetriever;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Requests\TakeDaysFromLastYearRequest;
 use Toby\Http\Requests\VacationLimitRequest;
-use Toby\Http\Resources\UserResource;
+use Toby\Http\Resources\SimpleUserResource;
+use Toby\Models\User;
 use Toby\Models\VacationLimit;
-use Toby\Models\YearPeriod;
 
 class VacationLimitController extends Controller
 {
-    public function edit(Request $request, YearPeriodRetriever $yearPeriodRetriever, UserVacationStatsRetriever $statsRetriever): Response
+    public function edit(Request $request, UserVacationStatsRetriever $statsRetriever): Response
     {
         $this->authorize("manageVacationLimits");
 
-        $yearPeriod = $yearPeriodRetriever->selected();
-        $previousYearPeriod = YearPeriod::findByYear($yearPeriod->year - 1);
+        $year = $request->integer("year", Carbon::now()->year);
 
-        $limits = $yearPeriod
-            ->vacationLimits()
-            ->whereRelation("user", fn(Builder $query): Builder => $query->withTrashed($request->user()->canSeeInactiveUsers()))
-            ->with("user.profile")
-            ->has("user")
+        $users = User::query()
+            ->with(["vacationLimits" => fn(HasMany $query): HasMany => $query->where("year", $year)->limit(1)])
+            ->withTrashed($request->user()->canSeeInactiveUsers())
             ->get()
-            ->sortBy(
-                fn(
-                    VacationLimit $limit,
-                ): string => "{$limit->user->profile->last_name} {$limit->user->profile->first_name}",
-            )
+            ->sortBy(fn(User $user): string => "{$user->profile->last_name} {$user->profile->first_name}")
             ->values();
 
-        $limitsResource = $limits->map(fn(VacationLimit $limit): array => [
-            "id" => $limit->id,
-            "user" => new UserResource($limit->user),
-            "hasVacation" => $limit->hasVacation(),
-            "days" => $limit->days,
-            "limit" => $limit->limit,
-            "fromPreviousYear" => $limit->from_previous_year,
-            "toNextYear" => $limit->to_next_year,
-            "remainingLastYear" => $previousYearPeriod
-                ? $statsRetriever->getRemainingVacationDays($limit->user, $previousYearPeriod)
-                : 0,
-        ]);
+        $limitsResource = $users->map(function (User $user) use ($statsRetriever, $year): array {
+            $limit = $user->vacationLimits->first();
+
+            return [
+                "user" => new SimpleUserResource($user),
+                "hasVacation" => $limit?->hasVacation() ?? false,
+                "days" => $limit?->days ?? 0,
+                "limit" => $limit?->limit ?? 0,
+                "fromPreviousYear" => $limit?->from_previous_year ?? 0,
+                "toNextYear" => $limit?->to_next_year ?? 0,
+                "remainingLastYear" => $statsRetriever->getRemainingVacationDays($user, $year - 1),
+            ];
+        });
 
         return inertia("VacationLimits", [
+            "year" => $year,
             "limits" => $limitsResource,
         ]);
     }
@@ -60,10 +55,14 @@ public function update(VacationLimitRequest $request): RedirectResponse
     {
         $this->authorize("manageVacationLimits");
 
-        $data = $request->data();
-
-        foreach ($request->vacationLimits() as $limit) {
-            $limit->update($data[$limit->id]);
+        foreach ($request->data() as $limit) {
+            VacationLimit::query()->updateOrCreate(
+                [
+                    "user_id" => $limit["user"],
+                    "year" => $limit["year"],
+                ],
+                ["days" => $limit["days"]],
+            );
         }
 
         return redirect()
@@ -71,26 +70,25 @@ public function update(VacationLimitRequest $request): RedirectResponse
             ->with("success", __("Vacation limits updated."));
     }
 
-    public function takeFromLastYear(
-        TakeDaysFromLastYearRequest $request,
-        VacationLimit $limit,
-    ): RedirectResponse {
+    public function takeFromLastYear(TakeDaysFromLastYearRequest $request): RedirectResponse
+    {
         $this->authorize("manageVacationLimits");
 
-        $days = $request->getDays();
-        $yearPeriod = $limit->yearPeriod;
-        $previousYearPeriod = YearPeriod::findByYear($yearPeriod->year - 1);
+        $data = $request->getData();
 
-        if ($previousYearPeriod) {
-            $previousLimit = $limit->user->vacationLimits()->whereBelongsTo($previousYearPeriod)->first();
+        $limit = VacationLimit::query()->updateOrCreate([
+            "user_id" => $data["user"],
+            "year" => $data["year"],
+        ], [
+            "from_previous_year" => $data["days"],
+        ]);
 
-            $previousLimit->update([
-                "to_next_year" => $days,
-            ]);
-        }
+        $previousLimit = $limit->user->vacationLimits()
+            ->where("year", $limit->year - 1)
+            ->first();
 
-        $limit->update([
-            "from_previous_year" => $days,
+        $previousLimit?->update([
+            "to_next_year" => $data["days"],
         ]);
 
         return redirect()
diff --git a/app/Http/Controllers/VacationRequestController.php b/app/Http/Controllers/VacationRequestController.php
index 693b0a1e..832b3390 100644
--- a/app/Http/Controllers/VacationRequestController.php
+++ b/app/Http/Controllers/VacationRequestController.php
@@ -10,6 +10,7 @@
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
 use Illuminate\Http\Response as LaravelResponse;
+use Illuminate\Support\Carbon;
 use Illuminate\Validation\ValidationException;
 use Inertia\Response;
 use Symfony\Component\HttpFoundation\Response as SymfonyResponse;
@@ -22,7 +23,6 @@
 use Toby\Domain\VacationRequestStatesRetriever;
 use Toby\Domain\VacationTypeConfigRetriever;
 use Toby\Enums\VacationType;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Requests\VacationRequestRequest;
 use Toby\Http\Resources\SimpleUserResource;
 use Toby\Http\Resources\SimpleVacationRequestResource;
@@ -35,7 +35,7 @@
 
 class VacationRequestController extends Controller
 {
-    public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever): Response|RedirectResponse
+    public function index(Request $request): Response|RedirectResponse
     {
         $user = $request->user();
 
@@ -43,13 +43,14 @@ public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever
             return redirect()->route("vacation.requests.indexForApprovers");
         }
 
+        $year = $request->integer("year", Carbon::now()->year);
         $status = $request->get("status", "all");
-        $withoutRemote = $request->boolean("withoutRemote", default: false);
+        $withoutRemote = $request->boolean("withoutRemote");
 
         $vacationRequests = $user
             ->vacationRequests()
             ->with(["vacations.user.profile", "user.permissions", "user.profile"])
-            ->whereBelongsTo($yearPeriodRetriever->selected())
+            ->whereYear("from", $year)
             ->latest()
             ->states(VacationRequestStatesRetriever::filterByStatusGroup($status, $user))
             ->when($withoutRemote, fn(Builder $query): Builder => $query->excludeType(VacationType::RemoteWork))
@@ -57,7 +58,7 @@ public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever
 
         $pending = $user
             ->vacationRequests()
-            ->whereBelongsTo($yearPeriodRetriever->selected())
+            ->whereYear("from", $year)
             ->states(VacationRequestStatesRetriever::pendingStates())
             ->when($withoutRemote, fn(Builder $query): Builder => $query->excludeType(VacationType::RemoteWork))
             ->cache(key: "vacations:{$user->id}")
@@ -65,7 +66,7 @@ public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever
 
         $success = $user
             ->vacationRequests()
-            ->whereBelongsTo($yearPeriodRetriever->selected())
+            ->whereYear("from", $year)
             ->states(VacationRequestStatesRetriever::successStates())
             ->when($withoutRemote, fn(Builder $query): Builder => $query->excludeType(VacationType::RemoteWork))
             ->cache(key: "vacations:{$user->id}")
@@ -73,7 +74,7 @@ public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever
 
         $failed = $user
             ->vacationRequests()
-            ->whereBelongsTo($yearPeriodRetriever->selected())
+            ->whereYear("from", $year)
             ->states(VacationRequestStatesRetriever::failedStates())
             ->when($withoutRemote, fn(Builder $query): Builder => $query->excludeType(VacationType::RemoteWork))
             ->cache(key: "vacations:{$user->id}")
@@ -89,19 +90,19 @@ public function index(Request $request, YearPeriodRetriever $yearPeriodRetriever
             ],
             "filters" => [
                 "status" => $status,
+                "year" => $year,
             ],
         ]);
     }
 
     public function indexForApprovers(
         Request $request,
-        YearPeriodRetriever $yearPeriodRetriever,
     ): RedirectResponse|Response {
         if ($request->user()->cannot("listAllRequests")) {
             return redirect()->route("vacation.requests.index");
         }
 
-        $yearPeriod = $yearPeriodRetriever->selected();
+        $year = $request->get("year");
         $status = $request->get("status", "all");
         $user = $request->get("user");
         $type = $request->get("type");
@@ -110,10 +111,10 @@ public function indexForApprovers(
 
         $vacationRequests = VacationRequest::query()
             ->with(["vacations.user.profile", "user.permissions", "user.profile"])
-            ->whereBelongsTo($yearPeriod)
             ->whereRelation("user", fn(Builder $query): Builder => $query->withTrashed($withTrashedUsers))
             ->when($user !== null, fn(Builder $query): Builder => $query->where("user_id", $user))
             ->when($type !== null, fn(Builder $query): Builder => $query->where("type", $type))
+            ->when($year !== null, fn(Builder $query): Builder => $query->whereYear("from", $year))
             ->states(VacationRequestStatesRetriever::filterByStatusGroup($status, $authUser))
             ->latest()
             ->paginate();
@@ -132,6 +133,7 @@ public function indexForApprovers(
                 "status" => $status,
                 "user" => (int)$user,
                 "type" => $type,
+                "year" => $year === null ? $year : (int)$year,
             ],
         ]);
     }
@@ -142,21 +144,22 @@ public function indexForApprovers(
     public function show(
         VacationRequest $vacationRequest,
         UserVacationStatsRetriever $statsRetriever,
-        YearPeriodRetriever $yearPeriodRetriever,
     ): Response {
         $this->authorize("show", $vacationRequest);
 
         $vacationRequest->load(["vacations.user.profile", "user.permissions", "user.profile", "activities.user.profile"]);
-        $limit = $statsRetriever->getVacationDaysLimit($vacationRequest->user, $vacationRequest->yearPeriod);
-        $used = $statsRetriever->getUsedVacationDays($vacationRequest->user, $vacationRequest->yearPeriod);
-        $pending = $statsRetriever->getPendingVacationDays($vacationRequest->user, $vacationRequest->yearPeriod);
+        $year = $vacationRequest->from->year;
+
+        $limit = $statsRetriever->getVacationDaysLimit($vacationRequest->user, $year);
+        $used = $statsRetriever->getUsedVacationDays($vacationRequest->user, $year);
+        $pending = $statsRetriever->getPendingVacationDays($vacationRequest->user, $year);
         $remaining = $limit - $used - $pending;
 
-        $yearPeriod = $yearPeriodRetriever->selected();
         $requestFromDateMonth = $vacationRequest->from->month;
         $requestToDateMonth = $vacationRequest->to->month;
 
-        $holidays = $yearPeriod->holidays()
+        $holidays = Holiday::query()
+            ->whereYear("date", $year)
             ->get();
 
         $user = $vacationRequest->user;
@@ -164,14 +167,14 @@ public function show(
         $vacations = $user
             ->vacations()
             ->with("vacationRequest.vacations")
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->approved()
             ->get();
 
         $pendingVacations = $user
             ->vacations()
             ->with("vacationRequest.vacations")
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->pending()
             ->get();
 
diff --git a/app/Http/Middleware/HandleInertiaRequests.php b/app/Http/Middleware/HandleInertiaRequests.php
index 23544729..0f053905 100644
--- a/app/Http/Middleware/HandleInertiaRequests.php
+++ b/app/Http/Middleware/HandleInertiaRequests.php
@@ -12,7 +12,6 @@
 use Spatie\Permission\Models\Permission;
 use Toby\Domain\OvertimeRequestStatesRetriever;
 use Toby\Domain\VacationRequestStatesRetriever;
-use Toby\Helpers\YearPeriodRetriever;
 use Toby\Http\Resources\UserResource;
 use Toby\Models\OvertimeRequest;
 use Toby\Models\User;
@@ -21,7 +20,6 @@
 class HandleInertiaRequests extends Middleware
 {
     public function __construct(
-        protected YearPeriodRetriever $yearPeriodRetriever,
         protected CacheManager $cache,
     ) {}
 
@@ -30,7 +28,6 @@ public function share(Request $request): array
         return array_merge(parent::share($request), [
             "auth" => $this->getAuthData($request),
             "flash" => $this->getFlashData($request),
-            "years" => $this->getYearsData($request),
             "vacationRequestsCount" => $this->getVacationRequestsCount($request),
             "overtimeRequestsCount" => $this->getOvertimeRequestsCount($request),
             "deployInformation" => $this->getDeployInformation(),
@@ -64,18 +61,12 @@ protected function getFlashData(Request $request): Closure
         ];
     }
 
-    protected function getYearsData(Request $request): Closure
-    {
-        return fn(): array => $request->user() ? $this->yearPeriodRetriever->links() : [];
-    }
-
     protected function getVacationRequestsCount(Request $request): Closure
     {
         $user = $request->user();
 
         return fn(): ?int => $user && $user->can("listAllRequests")
             ? VacationRequest::query()
-                ->whereBelongsTo($this->yearPeriodRetriever->selected())
                 ->states(
                     VacationRequestStatesRetriever::waitingForUserActionStates($user),
                 )
@@ -89,7 +80,6 @@ protected function getOvertimeRequestsCount(Request $request): Closure
 
         return fn(): ?int => $user && $user->can("listAllRequests")
             ? OvertimeRequest::query()
-                ->whereBelongsTo($this->yearPeriodRetriever->selected())
                 ->states(
                     OvertimeRequestStatesRetriever::waitingForUserActionStates($user),
                 )
diff --git a/app/Http/Requests/Api/CalculateOvertimeHoursRequest.php b/app/Http/Requests/Api/CalculateOvertimeHoursRequest.php
index 0529e5da..5b87808b 100644
--- a/app/Http/Requests/Api/CalculateOvertimeHoursRequest.php
+++ b/app/Http/Requests/Api/CalculateOvertimeHoursRequest.php
@@ -7,16 +7,14 @@
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Support\Carbon;
 use Toby\Helpers\DateFormats;
-use Toby\Http\Rules\YearPeriodExists;
-use Toby\Models\YearPeriod;
 
 class CalculateOvertimeHoursRequest extends FormRequest
 {
     public function rules(): array
     {
         return [
-            "from" => ["required", "date_format:" . DateFormats::DATETIME, new YearPeriodExists()],
-            "to" => ["required", "date_format:" . DateFormats::DATETIME, new YearPeriodExists()],
+            "from" => ["required", "date_format:" . DateFormats::DATETIME],
+            "to" => ["required", "date_format:" . DateFormats::DATETIME],
         ];
     }
 
@@ -29,9 +27,4 @@ public function to(): Carbon
     {
         return Carbon::create($this->request->get("to"));
     }
-
-    public function yearPeriod(): YearPeriod
-    {
-        return YearPeriod::findByYear(Carbon::create($this->request->get("from"))->year);
-    }
 }
diff --git a/app/Http/Requests/Api/CalculateUserUnavailableDaysRequest.php b/app/Http/Requests/Api/CalculateUserUnavailableDaysRequest.php
index 3ea65554..7a7c882e 100644
--- a/app/Http/Requests/Api/CalculateUserUnavailableDaysRequest.php
+++ b/app/Http/Requests/Api/CalculateUserUnavailableDaysRequest.php
@@ -5,6 +5,7 @@
 namespace Toby\Http\Requests\Api;
 
 use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Support\Carbon;
 use Illuminate\Validation\Rules\Enum;
 use Toby\Enums\VacationType;
 
@@ -15,6 +16,7 @@ public function rules(): array
         return [
             "vacationType" => [new Enum(VacationType::class)],
             "user" => ["required", "exists:users,id"],
+            "year" => ["required", "integer"],
         ];
     }
 
@@ -24,4 +26,9 @@ public function vacationType(): ?VacationType
             ? VacationType::from($this->request->get("vacationType"))
             : null;
     }
+
+    public function getYear(): int
+    {
+        return $this->integer("year", Carbon::now()->year);
+    }
 }
diff --git a/app/Http/Requests/Api/CalculateVacationDaysRequest.php b/app/Http/Requests/Api/CalculateVacationDaysRequest.php
index c8f2240f..e7df9263 100644
--- a/app/Http/Requests/Api/CalculateVacationDaysRequest.php
+++ b/app/Http/Requests/Api/CalculateVacationDaysRequest.php
@@ -9,8 +9,6 @@
 use Illuminate\Validation\Rules\Enum;
 use Toby\Enums\VacationType;
 use Toby\Helpers\DateFormats;
-use Toby\Http\Rules\YearPeriodExists;
-use Toby\Models\YearPeriod;
 
 class CalculateVacationDaysRequest extends FormRequest
 {
@@ -18,8 +16,8 @@ public function rules(): array
     {
         return [
             "vacationType" => ["required", new Enum(VacationType::class)],
-            "from" => ["required", "date_format:" . DateFormats::DATE, new YearPeriodExists()],
-            "to" => ["required", "date_format:" . DateFormats::DATE, new YearPeriodExists()],
+            "from" => ["required", "date_format:" . DateFormats::DATE],
+            "to" => ["required", "date_format:" . DateFormats::DATE],
         ];
     }
 
@@ -37,9 +35,4 @@ public function to(): Carbon
     {
         return Carbon::create($this->request->get("to"));
     }
-
-    public function yearPeriod(): YearPeriod
-    {
-        return YearPeriod::findByYear(Carbon::create($this->request->get("from"))->year);
-    }
 }
diff --git a/app/Http/Requests/Api/CalculateVacationStatsRequest.php b/app/Http/Requests/Api/CalculateVacationStatsRequest.php
index 0499f14b..8c378b1d 100644
--- a/app/Http/Requests/Api/CalculateVacationStatsRequest.php
+++ b/app/Http/Requests/Api/CalculateVacationStatsRequest.php
@@ -5,6 +5,7 @@
 namespace Toby\Http\Requests\Api;
 
 use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Support\Carbon;
 
 class CalculateVacationStatsRequest extends FormRequest
 {
@@ -12,6 +13,12 @@ public function rules(): array
     {
         return [
             "user" => ["required", "exists:users,id"],
+            "year" => ["required", "integer"],
         ];
     }
+
+    public function getYear(): int
+    {
+        return $this->integer("year", Carbon::now()->year);
+    }
 }
diff --git a/app/Http/Requests/HolidayRequest.php b/app/Http/Requests/HolidayRequest.php
index 1069f267..955fb966 100644
--- a/app/Http/Requests/HolidayRequest.php
+++ b/app/Http/Requests/HolidayRequest.php
@@ -5,11 +5,8 @@
 namespace Toby\Http\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
-use Illuminate\Support\Carbon;
 use Illuminate\Validation\Rule;
 use Toby\Helpers\DateFormats;
-use Toby\Http\Rules\YearPeriodExists;
-use Toby\Models\YearPeriod;
 
 class HolidayRequest extends FormRequest
 {
@@ -20,7 +17,6 @@ public function rules(): array
             "date" => ["required",
                 "date_format:" . DateFormats::DATE,
                 Rule::unique("holidays", "date")->ignore($this->holiday),
-                new YearPeriodExists(),
             ],
         ];
     }
@@ -32,7 +28,6 @@ public function data(): array
         return [
             "name" => $this->get("name"),
             "date" => $date,
-            "year_period_id" => YearPeriod::findByYear(Carbon::create($date)->year)->id,
         ];
     }
 }
diff --git a/app/Http/Requests/OvertimeRequestRequest.php b/app/Http/Requests/OvertimeRequestRequest.php
index 1470fb63..9c32cd62 100644
--- a/app/Http/Requests/OvertimeRequestRequest.php
+++ b/app/Http/Requests/OvertimeRequestRequest.php
@@ -5,12 +5,9 @@
 namespace Toby\Http\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
-use Illuminate\Support\Carbon;
 use Illuminate\Validation\Rules\Enum;
 use Toby\Enums\SettlementType;
 use Toby\Helpers\DateFormats;
-use Toby\Http\Rules\YearPeriodExists;
-use Toby\Models\YearPeriod;
 
 class OvertimeRequestRequest extends FormRequest
 {
@@ -18,8 +15,8 @@ public function rules(): array
     {
         return [
             "user" => ["required", "exists:users,id"],
-            "from" => ["required", "date_format:" . DateFormats::DATETIME, new YearPeriodExists()],
-            "to" => ["required", "date_format:" . DateFormats::DATETIME, "after:from", new YearPeriodExists()],
+            "from" => ["required", "date_format:" . DateFormats::DATETIME],
+            "to" => ["required", "date_format:" . DateFormats::DATETIME, "after:from"],
             "type" => ["required", new Enum(SettlementType::class)],
             "comment" => ["nullable"],
         ];
@@ -32,13 +29,7 @@ public function data(): array
             "from" => $this->get("from"),
             "to" => $this->get("to"),
             "settlement_type" => $this->get("type"),
-            "year_period_id" => $this->yearPeriod()->id,
             "comment" => $this->get("comment"),
         ];
     }
-
-    public function yearPeriod(): YearPeriod
-    {
-        return YearPeriod::findByYear(Carbon::create($this->get("from"))->year);
-    }
 }
diff --git a/app/Http/Requests/TakeDaysFromLastYearRequest.php b/app/Http/Requests/TakeDaysFromLastYearRequest.php
index be2be566..28d0554d 100644
--- a/app/Http/Requests/TakeDaysFromLastYearRequest.php
+++ b/app/Http/Requests/TakeDaysFromLastYearRequest.php
@@ -11,12 +11,14 @@ class TakeDaysFromLastYearRequest extends FormRequest
     public function rules(): array
     {
         return [
+            "user" => ["required", "exists:users,id"],
+            "year" => ["required", "integer"],
             "days" => ["required", "integer"],
         ];
     }
 
-    public function getDays(): int
+    public function getData(): array
     {
-        return $this->integer("days");
+        return $this->only(["user", "year", "days"]);
     }
 }
diff --git a/app/Http/Requests/VacationLimitRequest.php b/app/Http/Requests/VacationLimitRequest.php
index 9e01677a..e021b3db 100644
--- a/app/Http/Requests/VacationLimitRequest.php
+++ b/app/Http/Requests/VacationLimitRequest.php
@@ -6,7 +6,6 @@
 
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Support\Collection;
-use Toby\Models\VacationLimit;
 
 class VacationLimitRequest extends FormRequest
 {
@@ -14,20 +13,14 @@ public function rules(): array
     {
         return [
             "items" => ["required", "array"],
-            "items.*.id" => ["required", "exists:vacation_limits,id"],
+            "items.*.user" => ["required", "exists:users,id"],
+            "items.*.year" => ["required", "integer"],
             "items.*.days" => ["nullable", "integer", "min:0", "max:100"],
         ];
     }
 
-    public function vacationLimits(): Collection
+    public function data(): Collection
     {
-        return VacationLimit::query()->find($this->collect("items")->pluck("id"));
-    }
-
-    public function data(): array
-    {
-        return $this->collect("items")
-            ->keyBy("id")
-            ->toArray();
+        return $this->collect("items");
     }
 }
diff --git a/app/Http/Requests/VacationRequestRequest.php b/app/Http/Requests/VacationRequestRequest.php
index a089eaa5..4dca727c 100644
--- a/app/Http/Requests/VacationRequestRequest.php
+++ b/app/Http/Requests/VacationRequestRequest.php
@@ -5,12 +5,9 @@
 namespace Toby\Http\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
-use Illuminate\Support\Carbon;
 use Illuminate\Validation\Rules\Enum;
 use Toby\Enums\VacationType;
 use Toby\Helpers\DateFormats;
-use Toby\Http\Rules\YearPeriodExists;
-use Toby\Models\YearPeriod;
 
 class VacationRequestRequest extends FormRequest
 {
@@ -19,8 +16,8 @@ public function rules(): array
         return [
             "user" => ["required", "exists:users,id"],
             "type" => ["required", new Enum(VacationType::class)],
-            "from" => ["required", "date_format:" . DateFormats::DATE, new YearPeriodExists()],
-            "to" => ["required", "date_format:" . DateFormats::DATE, new YearPeriodExists()],
+            "from" => ["required", "date_format:" . DateFormats::DATE],
+            "to" => ["required", "date_format:" . DateFormats::DATE],
             "flowSkipped" => ["nullable", "boolean"],
             "comment" => ["nullable"],
         ];
@@ -33,17 +30,11 @@ public function data(): array
             "type" => $this->get("type"),
             "from" => $this->get("from"),
             "to" => $this->get("to"),
-            "year_period_id" => $this->yearPeriod()->id,
             "comment" => $this->get("comment"),
             "flow_skipped" => $this->boolean("flowSkipped"),
         ];
     }
 
-    public function yearPeriod(): YearPeriod
-    {
-        return YearPeriod::findByYear(Carbon::create($this->get("from"))->year);
-    }
-
     public function createsOnBehalfOfEmployee(): bool
     {
         return $this->user()->id !== $this->get("user");
diff --git a/app/Http/Resources/SimpleUserResource.php b/app/Http/Resources/SimpleUserResource.php
index 006c9913..064fc770 100644
--- a/app/Http/Resources/SimpleUserResource.php
+++ b/app/Http/Resources/SimpleUserResource.php
@@ -16,6 +16,7 @@ public function toArray($request): array
             "id" => $this->id,
             "name" => $this->profile->full_name,
             "last_name" => $this->profile->last_name,
+            "employmentForm" => $this->profile->employment_form->label(),
             "email" => $this->email,
             "avatar" => $this->profile->getAvatar(),
             "isActive" => $this->deleted_at === null,
diff --git a/app/Http/Rules/YearPeriodExists.php b/app/Http/Rules/YearPeriodExists.php
deleted file mode 100644
index 1df8053a..00000000
--- a/app/Http/Rules/YearPeriodExists.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Toby\Http\Rules;
-
-use Closure;
-use Illuminate\Contracts\Validation\ValidationRule;
-use Illuminate\Support\Carbon;
-use Toby\Models\YearPeriod;
-
-class YearPeriodExists implements ValidationRule
-{
-    public function validate(string $attribute, mixed $value, Closure $fail): void
-    {
-        $yearPeriod = YearPeriod::findByYear(Carbon::create($value)->year);
-
-        if ($yearPeriod === null) {
-            $fail(__("The year period for given year does not exist."));
-        }
-    }
-}
diff --git a/app/Jobs/CheckYearPeriod.php b/app/Jobs/CheckYearPeriod.php
deleted file mode 100644
index 0be0fefa..00000000
--- a/app/Jobs/CheckYearPeriod.php
+++ /dev/null
@@ -1,32 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Toby\Jobs;
-
-use Illuminate\Bus\Queueable;
-use Illuminate\Contracts\Queue\ShouldQueue;
-use Illuminate\Foundation\Bus\Dispatchable;
-use Illuminate\Support\Carbon;
-use Toby\Actions\CreateYearPeriodAction;
-use Toby\Models\YearPeriod;
-
-class CheckYearPeriod implements ShouldQueue
-{
-    use Dispatchable;
-    use Queueable;
-
-    public function handle(CreateYearPeriodAction $createYearPeriodAction): void
-    {
-        $currentYearPeriod = YearPeriod::current();
-        $now = Carbon::now();
-
-        if ($currentYearPeriod === null) {
-            $createYearPeriodAction->execute($now->year);
-        }
-
-        if (YearPeriod::query()->max("year") === $now->year) {
-            $createYearPeriodAction->execute($now->year + 1);
-        }
-    }
-}
diff --git a/app/Models/Holiday.php b/app/Models/Holiday.php
index b8c17542..0e3adf76 100644
--- a/app/Models/Holiday.php
+++ b/app/Models/Holiday.php
@@ -7,14 +7,12 @@
 use Database\Factories\HolidayFactory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Support\Carbon;
 
 /**
  * @property int $id
  * @property string $name
  * @property Carbon $date
- * @property YearPeriod $yearPeriod
  */
 class Holiday extends Model
 {
@@ -25,11 +23,6 @@ class Holiday extends Model
         "date" => "date",
     ];
 
-    public function yearPeriod(): BelongsTo
-    {
-        return $this->belongsTo(YearPeriod::class);
-    }
-
     protected static function newFactory(): HolidayFactory
     {
         return HolidayFactory::new();
diff --git a/app/Models/OvertimeRequest.php b/app/Models/OvertimeRequest.php
index 7fc3ebdb..ea8ada59 100644
--- a/app/Models/OvertimeRequest.php
+++ b/app/Models/OvertimeRequest.php
@@ -28,7 +28,6 @@
  * @property string $comment
  * @property User $user
  * @property User $creator
- * @property YearPeriod $yearPeriod
  * @property Collection $activities
  * @property Carbon $created_at
  * @property Carbon $updated_at
@@ -59,11 +58,6 @@ public function creator(): BelongsTo
         return $this->belongsTo(User::class, "creator_id");
     }
 
-    public function yearPeriod(): BelongsTo
-    {
-        return $this->belongsTo(YearPeriod::class);
-    }
-
     public function activities(): HasMany
     {
         return $this->hasMany(OvertimeRequestActivity::class);
diff --git a/app/Models/User.php b/app/Models/User.php
index d4b5f565..26c32163 100644
--- a/app/Models/User.php
+++ b/app/Models/User.php
@@ -142,10 +142,10 @@ public function keys(): HasMany
         return $this->hasMany(Key::class);
     }
 
-    public function hasVacationLimit(YearPeriod $yearPeriod): bool
+    public function hasVacationLimit(int $year): bool
     {
         return $this->vacationLimits()
-            ->whereBelongsTo($yearPeriod)
+            ->where("year", $year)
             ->whereNotNull("days")
             ->exists();
     }
@@ -181,12 +181,12 @@ public function scopeOrderByUserHistoryField(Builder $query, string $field, stri
         return $query->orderBy($profileQuery, $direction);
     }
 
-    public function scopeWithVacationLimitIn(Builder $query, YearPeriod $yearPeriod): Builder
+    public function scopeWithVacationLimitIn(Builder $query, int $year): Builder
     {
         return $query->whereRelation(
             "vacationlimits",
             fn(Builder $query): Builder => $query
-                ->whereBelongsTo($yearPeriod)
+                ->where("year", $year)
                 ->whereNotNull("days"),
         );
     }
@@ -211,7 +211,7 @@ public function upcomingBirthday(): ?Carbon
 
         $birthday = $this->profile->birthday->setYear($today->year);
 
-        if (((int)$birthday->diffInDays(absolute: false)) > 0) {
+        if (((int)$birthday->diffInDays()) > 0) {
             $birthday->setYear($today->year + 1);
         }
 
diff --git a/app/Models/Vacation.php b/app/Models/Vacation.php
index f7eba140..daf4a1c9 100644
--- a/app/Models/Vacation.php
+++ b/app/Models/Vacation.php
@@ -18,7 +18,6 @@
  * @property Carbon $date
  * @property User $user
  * @property VacationRequest $vacationRequest
- * @property YearPeriod $yearPeriod
  */
 class Vacation extends Model
 {
@@ -41,11 +40,6 @@ public function vacationRequest(): BelongsTo
         return $this->belongsTo(VacationRequest::class);
     }
 
-    public function yearPeriod(): BelongsTo
-    {
-        return $this->belongsTo(YearPeriod::class);
-    }
-
     public function scopeApproved(Builder $query): Builder
     {
         return $query->whereRelation(
diff --git a/app/Models/VacationLimit.php b/app/Models/VacationLimit.php
index 06fbfd33..1dc4d46b 100644
--- a/app/Models/VacationLimit.php
+++ b/app/Models/VacationLimit.php
@@ -12,7 +12,7 @@
 /**
  * @property int $id
  * @property User $user
- * @property YearPeriod $yearPeriod
+ * @property int $year
  * @property int $limit
  * @property int $days
  * @property int $from_previous_year
@@ -35,11 +35,6 @@ public function user(): BelongsTo
             ->withTrashed();
     }
 
-    public function yearPeriod(): BelongsTo
-    {
-        return $this->belongsTo(YearPeriod::class);
-    }
-
     protected static function newFactory(): VacationLimitFactory
     {
         return VacationLimitFactory::new();
diff --git a/app/Models/VacationRequest.php b/app/Models/VacationRequest.php
index 42c7aab8..6c9bea24 100644
--- a/app/Models/VacationRequest.php
+++ b/app/Models/VacationRequest.php
@@ -29,7 +29,6 @@
  * @property bool $flow_skipped
  * @property User $user
  * @property User $creator
- * @property YearPeriod $yearPeriod
  * @property Collection $activities
  * @property Collection $vacations
  * @property Collection $event_ids
@@ -62,11 +61,6 @@ public function creator(): BelongsTo
         return $this->belongsTo(User::class, "creator_id");
     }
 
-    public function yearPeriod(): BelongsTo
-    {
-        return $this->belongsTo(YearPeriod::class);
-    }
-
     public function activities(): HasMany
     {
         return $this->hasMany(VacationRequestActivity::class);
diff --git a/app/Models/YearPeriod.php b/app/Models/YearPeriod.php
deleted file mode 100644
index edb010fa..00000000
--- a/app/Models/YearPeriod.php
+++ /dev/null
@@ -1,83 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Toby\Models;
-
-use Database\Factories\YearPeriodFactory;
-use Illuminate\Database\Eloquent\Factories\HasFactory;
-use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\Relations\HasMany;
-use Illuminate\Support\Carbon;
-use Illuminate\Support\Collection;
-
-/**
- * @property int $id
- * @property int $year
- * @property Collection $vacationLimits
- * @property Collection $vacationRequests
- * @property Collection $overtimeRequests
- * @property Collection $holidays
- */
-class YearPeriod extends Model
-{
-    use HasFactory;
-
-    protected $guarded = [];
-
-    public static function current(): ?static
-    {
-        return static::findByYear(Carbon::now()->year);
-    }
-
-    public static function findByYear(int $year): ?static
-    {
-        /** @var YearPeriod $year */
-        $year = static::query()->where("year", $year)->first();
-
-        return $year;
-    }
-
-    public function vacationLimits(): HasMany
-    {
-        return $this->hasMany(VacationLimit::class);
-    }
-
-    public function vacationRequests(): HasMany
-    {
-        return $this->hasMany(VacationRequest::class);
-    }
-
-    public function overtimeRequests(): HasMany
-    {
-        return $this->hasMany(OvertimeRequest::class);
-    }
-
-    public function holidays(): HasMany
-    {
-        return $this->hasMany(Holiday::class);
-    }
-
-    public function weekends(): Collection
-    {
-        $start = Carbon::create($this->year);
-        $end = Carbon::create($this->year)->endOfYear();
-
-        $weekends = new Collection();
-
-        while ($start->lessThanOrEqualTo($end)) {
-            if ($start->isWeekend()) {
-                $weekends->push($start->copy());
-            }
-
-            $start->addDay();
-        }
-
-        return $weekends;
-    }
-
-    protected static function newFactory(): YearPeriodFactory
-    {
-        return YearPeriodFactory::new();
-    }
-}
diff --git a/app/Observers/OvertimeRequestObserver.php b/app/Observers/OvertimeRequestObserver.php
index 700915d6..b01f7636 100644
--- a/app/Observers/OvertimeRequestObserver.php
+++ b/app/Observers/OvertimeRequestObserver.php
@@ -11,10 +11,13 @@ class OvertimeRequestObserver
 {
     public function creating(OvertimeRequest $overtime): void
     {
-        $count = $overtime->yearPeriod->overtimeRequests()->count();
+        $count = OvertimeRequest::query()
+            ->whereYear("from", $overtime->from)
+            ->count();
+
         $number = $count + 1;
 
-        $overtime->name = "N/{$number}/{$overtime->yearPeriod->year}";
+        $overtime->name = "N/{$number}/{$overtime->from->year}";
     }
 
     public function updating(OvertimeRequest $overtime): void
diff --git a/app/Observers/VacationRequestObserver.php b/app/Observers/VacationRequestObserver.php
index 414ba813..ad848177 100644
--- a/app/Observers/VacationRequestObserver.php
+++ b/app/Observers/VacationRequestObserver.php
@@ -11,10 +11,13 @@ class VacationRequestObserver
 {
     public function creating(VacationRequest $vacationRequest): void
     {
-        $count = $vacationRequest->yearPeriod->vacationRequests()->count();
+        $count = VacationRequest::query()
+            ->whereYear("from", $vacationRequest->from)
+            ->count();
+
         $number = $count + 1;
 
-        $vacationRequest->name = "{$number}/{$vacationRequest->yearPeriod->year}";
+        $vacationRequest->name = "{$number}/{$vacationRequest->from->year}";
     }
 
     public function updating(VacationRequest $vacationRequest): void
diff --git a/app/Slack/Handlers/RemoteWork.php b/app/Slack/Handlers/RemoteWork.php
index bcf87152..6f28a881 100644
--- a/app/Slack/Handlers/RemoteWork.php
+++ b/app/Slack/Handlers/RemoteWork.php
@@ -10,7 +10,6 @@
 use Toby\Actions\VacationRequest\CreateAction;
 use Toby\Enums\VacationType;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 use Toby\Slack\Traits\FindsUserBySlackId;
 
 class RemoteWork extends SignatureHandler
@@ -31,14 +30,11 @@ public function handle(Request $request): Response
 
     protected function createRemoteDay(User $user, Carbon $date): void
     {
-        $yearPeriod = YearPeriod::findByYear($date->year);
-
         app(CreateAction::class)->execute([
             "user_id" => $user->id,
             "type" => VacationType::RemoteWork,
             "from" => $date,
             "to" => $date,
-            "year_period_id" => $yearPeriod->id,
             "flow_skipped" => false,
         ], $user);
     }
diff --git a/app/Validation/Rules/VacationRequest/DoesNotExceedLimitRule.php b/app/Validation/Rules/VacationRequest/DoesNotExceedLimitRule.php
index fab4db12..58eb385c 100644
--- a/app/Validation/Rules/VacationRequest/DoesNotExceedLimitRule.php
+++ b/app/Validation/Rules/VacationRequest/DoesNotExceedLimitRule.php
@@ -12,7 +12,6 @@
 use Toby\Enums\VacationType;
 use Toby\Models\User;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 
 class DoesNotExceedLimitRule implements VacationRequestRule
 {
@@ -27,8 +26,8 @@ public function check(VacationRequest $vacationRequest): bool
             return true;
         }
 
-        $limit = $this->getUserVacationLimit($vacationRequest->user, $vacationRequest->yearPeriod);
-        $vacationDays = $this->getVacationDaysWithLimit($vacationRequest->user, $vacationRequest->yearPeriod);
+        $limit = $this->getUserVacationLimit($vacationRequest->user, $vacationRequest->from->year);
+        $vacationDays = $this->getVacationDaysWithLimit($vacationRequest->user, $vacationRequest->from->year);
         $estimatedDays = $this->workDaysCalculator
             ->calculateDays($vacationRequest->from, $vacationRequest->to, $vacationRequest->type)
             ->count();
@@ -41,18 +40,18 @@ public function errorMessage(): string
         return __("Vacation limit has been exceeded.");
     }
 
-    protected function getUserVacationLimit(User $user, YearPeriod $yearPeriod): int
+    protected function getUserVacationLimit(User $user, int $year): int
     {
         return $user->vacationLimits()
-            ->whereBelongsTo($yearPeriod)
+            ->where("year", $year)
             ->first()
             ?->limit ?? 0;
     }
 
-    protected function getVacationDaysWithLimit(User $user, YearPeriod $yearPeriod): int
+    protected function getVacationDaysWithLimit(User $user, int $year): int
     {
         return $user->vacations()
-            ->whereBelongsTo($yearPeriod)
+            ->whereYear("date", $year)
             ->whereRelation(
                 "vacationRequest",
                 fn(Builder $query): Builder => $query
diff --git a/database/factories/HolidayFactory.php b/database/factories/HolidayFactory.php
index 7d4ca0bd..686bdd3c 100644
--- a/database/factories/HolidayFactory.php
+++ b/database/factories/HolidayFactory.php
@@ -6,7 +6,6 @@
 
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Toby\Models\Holiday;
-use Toby\Models\YearPeriod;
 
 class HolidayFactory extends Factory
 {
@@ -17,7 +16,6 @@ public function definition(): array
         return [
             "name" => $this->faker->word,
             "date" => $this->faker->unique->date,
-            "year_period_id" => YearPeriod::current()->id,
         ];
     }
 }
diff --git a/database/factories/OvertimeRequestFactory.php b/database/factories/OvertimeRequestFactory.php
index 37e665cb..fe3e0561 100644
--- a/database/factories/OvertimeRequestFactory.php
+++ b/database/factories/OvertimeRequestFactory.php
@@ -10,7 +10,6 @@
 use Toby\Enums\SettlementType;
 use Toby\Models\OvertimeRequest;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 class OvertimeRequestFactory extends Factory
 {
@@ -25,7 +24,6 @@ public function definition(): array
         return [
             "user_id" => User::factory(),
             "creator_id" => fn(array $attributes): int => $attributes["user_id"],
-            "year_period_id" => YearPeriod::factory(),
             "state" => $this->faker->randomElement(OvertimeRequestStatesRetriever::all()),
             "from" => $from,
             "to" => $to,
diff --git a/database/factories/VacationFactory.php b/database/factories/VacationFactory.php
index 9abea039..f74676b0 100644
--- a/database/factories/VacationFactory.php
+++ b/database/factories/VacationFactory.php
@@ -9,7 +9,6 @@
 use Toby\Models\User;
 use Toby\Models\Vacation;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 
 class VacationFactory extends Factory
 {
@@ -20,7 +19,6 @@ public function definition(): array
         return [
             "user_id" => User::factory(),
             "vacation_request_id" => VacationRequest::factory(),
-            "year_period_id" => YearPeriod::factory(),
             "date" => CarbonImmutable::create($this->faker->dateTimeThisYear),
         ];
     }
diff --git a/database/factories/VacationLimitFactory.php b/database/factories/VacationLimitFactory.php
index 20a63c56..e2875d7d 100644
--- a/database/factories/VacationLimitFactory.php
+++ b/database/factories/VacationLimitFactory.php
@@ -7,7 +7,6 @@
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Toby\Models\User;
 use Toby\Models\VacationLimit;
-use Toby\Models\YearPeriod;
 
 class VacationLimitFactory extends Factory
 {
@@ -19,7 +18,7 @@ public function definition(): array
 
         return [
             "user_id" => User::factory(),
-            "year_period_id" => YearPeriod::factory(),
+            "year" => fake()->dateTimeThisDecade()->format("Y"),
             "days" => $hasVacation ? $this->faker->numberBetween(20, 26) : null,
             "from_previous_year" => $hasVacation ? 0 : null,
             "to_next_year" => $hasVacation ? 0 : null,
diff --git a/database/factories/VacationRequestFactory.php b/database/factories/VacationRequestFactory.php
index 235f50ce..6451a7df 100644
--- a/database/factories/VacationRequestFactory.php
+++ b/database/factories/VacationRequestFactory.php
@@ -10,7 +10,6 @@
 use Toby\Enums\VacationType;
 use Toby\Models\User;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 
 class VacationRequestFactory extends Factory
 {
@@ -24,7 +23,6 @@ public function definition(): array
         return [
             "user_id" => User::factory(),
             "creator_id" => fn(array $attributes): int => $attributes["user_id"],
-            "year_period_id" => YearPeriod::factory(),
             "type" => $this->faker->randomElement(VacationType::cases()),
             "state" => $this->faker->randomElement(VacationRequestStatesRetriever::all()),
             "from" => $from,
diff --git a/database/factories/YearPeriodFactory.php b/database/factories/YearPeriodFactory.php
deleted file mode 100644
index f9fe4a27..00000000
--- a/database/factories/YearPeriodFactory.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Database\Factories;
-
-use Illuminate\Database\Eloquent\Factories\Factory;
-use Toby\Models\YearPeriod;
-
-class YearPeriodFactory extends Factory
-{
-    protected $model = YearPeriod::class;
-
-    public function definition(): array
-    {
-        return [
-            "year" => (int)$this->faker->unique()->year,
-        ];
-    }
-}
diff --git a/database/migrations/2022_01_19_140630_create_vacation_limits_table.php b/database/migrations/2022_01_19_140630_create_vacation_limits_table.php
index c2b29d50..0a2ab4c6 100644
--- a/database/migrations/2022_01_19_140630_create_vacation_limits_table.php
+++ b/database/migrations/2022_01_19_140630_create_vacation_limits_table.php
@@ -6,7 +6,6 @@
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 return new class() extends Migration {
     public function up(): void
@@ -14,7 +13,7 @@ public function up(): void
         Schema::create("vacation_limits", function (Blueprint $table): void {
             $table->id();
             $table->foreignIdFor(User::class)->constrained()->cascadeOnDelete();
-            $table->foreignIdFor(YearPeriod::class)->constrained()->cascadeOnDelete();
+            $table->foreignId("year_period_id")->constrained()->cascadeOnDelete();
             $table->integer("days")->nullable();
             $table->timestamps();
         });
diff --git a/database/migrations/2022_01_20_140544_create_holidays_table.php b/database/migrations/2022_01_20_140544_create_holidays_table.php
index 941418c3..f802ccc3 100644
--- a/database/migrations/2022_01_20_140544_create_holidays_table.php
+++ b/database/migrations/2022_01_20_140544_create_holidays_table.php
@@ -5,14 +5,13 @@
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
-use Toby\Models\YearPeriod;
 
 return new class() extends Migration {
     public function up(): void
     {
         Schema::create("holidays", function (Blueprint $table): void {
             $table->id();
-            $table->foreignIdFor(YearPeriod::class)->constrained()->cascadeOnDelete();
+            $table->foreignId("year_period_id")->constrained()->cascadeOnDelete();
             $table->string("name");
             $table->date("date")->unique();
             $table->timestamps();
diff --git a/database/migrations/2022_01_26_100039_create_vacation_requests_table.php b/database/migrations/2022_01_26_100039_create_vacation_requests_table.php
index f5513517..f333847d 100644
--- a/database/migrations/2022_01_26_100039_create_vacation_requests_table.php
+++ b/database/migrations/2022_01_26_100039_create_vacation_requests_table.php
@@ -6,7 +6,6 @@
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 return new class() extends Migration {
     public function up(): void
@@ -16,7 +15,7 @@ public function up(): void
             $table->string("name");
             $table->foreignIdFor(User::class, "creator_id")->constrained("users")->cascadeOnDelete();
             $table->foreignIdFor(User::class)->constrained()->cascadeOnDelete();
-            $table->foreignIdFor(YearPeriod::class)->constrained()->cascadeOnDelete();
+            $table->foreignId("year_period_id")->constrained()->cascadeOnDelete();
             $table->string("type");
             $table->string("state")->nullable();
             $table->date("from");
diff --git a/database/migrations/2022_02_07_133018_create_vacations_table.php b/database/migrations/2022_02_07_133018_create_vacations_table.php
index 3ddadd51..ae51f02c 100644
--- a/database/migrations/2022_02_07_133018_create_vacations_table.php
+++ b/database/migrations/2022_02_07_133018_create_vacations_table.php
@@ -7,7 +7,6 @@
 use Illuminate\Support\Facades\Schema;
 use Toby\Models\User;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 
 return new class() extends Migration {
     public function up(): void
@@ -16,7 +15,7 @@ public function up(): void
             $table->id();
             $table->foreignIdFor(User::class)->constrained()->cascadeOnDelete();
             $table->foreignIdFor(VacationRequest::class)->constrained()->cascadeOnDelete();
-            $table->foreignIdFor(YearPeriod::class)->constrained()->cascadeOnDelete();
+            $table->foreignId("year_period_id")->constrained()->cascadeOnDelete();
             $table->string("event_id")->nullable();
             $table->date("date");
         });
diff --git a/database/migrations/2024_06_06_080039_create_overtime_requests_table.php b/database/migrations/2024_06_06_080039_create_overtime_requests_table.php
index 5967cd4d..76b7c696 100644
--- a/database/migrations/2024_06_06_080039_create_overtime_requests_table.php
+++ b/database/migrations/2024_06_06_080039_create_overtime_requests_table.php
@@ -6,7 +6,6 @@
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\Schema;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 return new class() extends Migration {
     public function up(): void
@@ -16,7 +15,7 @@ public function up(): void
             $table->string("name");
             $table->foreignIdFor(User::class, "creator_id")->constrained("users")->cascadeOnDelete();
             $table->foreignIdFor(User::class)->constrained()->cascadeOnDelete();
-            $table->foreignIdFor(YearPeriod::class)->constrained()->cascadeOnDelete();
+            $table->foreignId("year_period_id")->constrained()->cascadeOnDelete();
             $table->string("state")->nullable();
             $table->string("settlement_type");
             $table->boolean("settled")->default(false);
diff --git a/database/migrations/2024_10_14_110718_delete_year_period_foreign_and_add_year_to_vacation_limits_table.php b/database/migrations/2024_10_14_110718_delete_year_period_foreign_and_add_year_to_vacation_limits_table.php
new file mode 100644
index 00000000..88cbdf29
--- /dev/null
+++ b/database/migrations/2024_10_14_110718_delete_year_period_foreign_and_add_year_to_vacation_limits_table.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Artisan;
+use Illuminate\Support\Facades\Schema;
+use Toby\Console\Commands\MigrateYearPeriodYearToVacationLimits;
+
+return new class() extends Migration {
+    public function up(): void
+    {
+        Schema::table("vacation_limits", function (Blueprint $table): void {
+            $table->integer("year")->nullable();
+        });
+
+        Artisan::call(MigrateYearPeriodYearToVacationLimits::class);
+
+        Schema::table("vacation_limits", function (Blueprint $table): void {
+            $table->integer("year")->nullable(false)->change();
+            $table->dropConstrainedForeignId("year_period_id");
+        });
+    }
+};
diff --git a/database/migrations/2024_10_14_110737_delete_year_period_foreign_from_holidays_table.php b/database/migrations/2024_10_14_110737_delete_year_period_foreign_from_holidays_table.php
new file mode 100644
index 00000000..d7e9d73e
--- /dev/null
+++ b/database/migrations/2024_10_14_110737_delete_year_period_foreign_from_holidays_table.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class() extends Migration {
+    public function up(): void
+    {
+        Schema::table("holidays", function (Blueprint $table): void {
+            $table->dropConstrainedForeignId("year_period_id");
+        });
+    }
+};
diff --git a/database/migrations/2024_10_14_110744_delete_year_period_foreign_from_vacations_table.php b/database/migrations/2024_10_14_110744_delete_year_period_foreign_from_vacations_table.php
new file mode 100644
index 00000000..f69f9824
--- /dev/null
+++ b/database/migrations/2024_10_14_110744_delete_year_period_foreign_from_vacations_table.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class() extends Migration {
+    public function up(): void
+    {
+        Schema::table("vacations", function (Blueprint $table): void {
+            $table->dropConstrainedForeignId("year_period_id");
+        });
+    }
+};
diff --git a/database/migrations/2024_10_14_110753_delete_year_period_foreign_from_overtime_requests_table.php b/database/migrations/2024_10_14_110753_delete_year_period_foreign_from_overtime_requests_table.php
new file mode 100644
index 00000000..84921162
--- /dev/null
+++ b/database/migrations/2024_10_14_110753_delete_year_period_foreign_from_overtime_requests_table.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class() extends Migration {
+    public function up(): void
+    {
+        Schema::table("overtime_requests", function (Blueprint $table): void {
+            $table->dropConstrainedForeignId("year_period_id");
+        });
+    }
+};
diff --git a/database/migrations/2024_10_14_110830_delete_year_period_foreign_from_vacation_requests_table.php b/database/migrations/2024_10_14_110830_delete_year_period_foreign_from_vacation_requests_table.php
new file mode 100644
index 00000000..f5156a43
--- /dev/null
+++ b/database/migrations/2024_10_14_110830_delete_year_period_foreign_from_vacation_requests_table.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class() extends Migration {
+    public function up(): void
+    {
+        Schema::table("vacation_requests", function (Blueprint $table): void {
+            $table->dropConstrainedForeignId("year_period_id");
+        });
+    }
+};
diff --git a/database/migrations/2024_10_14_110841_delete_year_periods_table.php b/database/migrations/2024_10_14_110841_delete_year_periods_table.php
new file mode 100644
index 00000000..9d929f98
--- /dev/null
+++ b/database/migrations/2024_10_14_110841_delete_year_periods_table.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\Schema;
+
+return new class() extends Migration {
+    public function up(): void
+    {
+        Schema::dropIfExists("year_periods");
+    }
+};
diff --git a/database/seeders/DatabaseSeeder.php b/database/seeders/DatabaseSeeder.php
index c89e46ad..a6676781 100644
--- a/database/seeders/DatabaseSeeder.php
+++ b/database/seeders/DatabaseSeeder.php
@@ -12,11 +12,10 @@
 use Toby\Models\BenefitsReport;
 use Toby\Models\EquipmentItem;
 use Toby\Models\EquipmentLabel;
+use Toby\Models\Holiday;
 use Toby\Models\Key;
 use Toby\Models\User;
-use Toby\Models\VacationLimit;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 
 class DatabaseSeeder extends Seeder
 {
@@ -33,49 +32,24 @@ public function run(): void
 
         $users = User::all();
 
-        YearPeriod::factory()
-            ->count(3)
-            ->sequence(
-                [
-                    "year" => Carbon::now()->year - 1,
-                ],
-                [
-                    "year" => Carbon::now()->year,
-                ],
-                [
-                    "year" => Carbon::now()->year + 1,
-                ],
-            )
-            ->afterCreating(function (YearPeriod $yearPeriod) use ($users): void {
-                foreach ($users as $user) {
-                    VacationLimit::factory()
-                        ->for($yearPeriod)
-                        ->for($user)
-                        ->create();
-                }
-            })
-            ->afterCreating(function (YearPeriod $yearPeriod): void {
-                $polishHolidaysRetriever = new PolishHolidaysRetriever();
-
-                foreach ($polishHolidaysRetriever->getForYearPeriod($yearPeriod) as $holiday) {
-                    $yearPeriod->holidays()->create([
-                        "name" => $holiday["name"],
-                        "date" => $holiday["date"],
-                    ]);
-                }
-            })
-            ->create();
+        $year = Carbon::now()->year;
+
+        foreach ([$year - 1, $year, $year + 1] as $i) {
+            $polishHolidaysRetriever = new PolishHolidaysRetriever();
 
-        $yearPeriods = YearPeriod::all();
+            foreach ($polishHolidaysRetriever->getForYear($i) as $holiday) {
+                Holiday::query()->create([
+                    "name" => $holiday["name"],
+                    "date" => $holiday["date"],
+                ]);
+            }
+        }
 
         foreach ($users as $user) {
             VacationRequest::factory()
                 ->count(50)
                 ->for($user)
                 ->for($user, "creator")
-                ->sequence(fn() => [
-                    "year_period_id" => $yearPeriods->random()->id,
-                ])
                 ->afterCreating(function (VacationRequest $vacationRequest): void {
                     $days = app(WorkDaysCalculator::class)->calculateDays(
                         $vacationRequest->from,
@@ -87,7 +61,6 @@ public function run(): void
                         $vacationRequest->vacations()->create([
                             "date" => $day,
                             "user_id" => $vacationRequest->user->id,
-                            "year_period_id" => $vacationRequest->yearPeriod->id,
                         ]);
                     }
                 })
diff --git a/database/seeders/DemoSeeder.php b/database/seeders/DemoSeeder.php
index 18689544..e9cd6f11 100644
--- a/database/seeders/DemoSeeder.php
+++ b/database/seeders/DemoSeeder.php
@@ -17,6 +17,7 @@
 use Toby\Models\BenefitsReport;
 use Toby\Models\EquipmentItem;
 use Toby\Models\EquipmentLabel;
+use Toby\Models\Holiday;
 use Toby\Models\Key;
 use Toby\Models\Resume;
 use Toby\Models\Technology;
@@ -24,7 +25,6 @@
 use Toby\Models\VacationLimit;
 use Toby\Models\VacationRequest;
 use Toby\Models\VacationRequestActivity;
-use Toby\Models\YearPeriod;
 use Toby\States\VacationRequest\AcceptedByAdministrative;
 use Toby\States\VacationRequest\AcceptedByTechnical;
 use Toby\States\VacationRequest\Approved;
@@ -184,54 +184,33 @@ public function run(): void
 
         $year = Carbon::now()->year;
 
-        YearPeriod::factory()
-            ->count(3)
-            ->sequence(
-                [
-                    "year" => Carbon::createFromDate($year - 1)->year,
-                ],
-                [
-                    "year" => Carbon::createFromDate($year)->year,
-                ],
-                [
-                    "year" => Carbon::createFromDate($year + 1)->year,
-                ],
-            )
-            ->afterCreating(function (YearPeriod $yearPeriod) use ($users): void {
-                foreach ($users as $user) {
-                    VacationLimit::factory([
-                        "days" => $user->profile->employment_form === EmploymentForm::EmploymentContract ? 26 : null,
-                    ])
-                        ->for($yearPeriod)
-                        ->for($user)
-                        ->create();
-                }
-            })
-            ->afterCreating(function (YearPeriod $yearPeriod): void {
-                $polishHolidaysRetriever = new PolishHolidaysRetriever();
+        foreach ([$year - 1, $year, $year + 1] as $i) {
+            $polishHolidaysRetriever = new PolishHolidaysRetriever();
 
-                foreach ($polishHolidaysRetriever->getForYearPeriod($yearPeriod) as $holiday) {
-                    $yearPeriod->holidays()->create([
-                        "name" => $holiday["name"],
-                        "date" => $holiday["date"],
-                    ]);
-                }
-            })
-            ->create();
+            foreach ($polishHolidaysRetriever->getForYear($i) as $holiday) {
+                Holiday::query()->create([
+                    "name" => $holiday["name"],
+                    "date" => $holiday["date"],
+                ]);
+            }
+        }
 
-        $currentYearPeriod = YearPeriod::query()->where("year", $year)->first();
+        foreach ($users as $item) {
+            VacationLimit::factory()
+                ->for($item)
+                ->create(["year" => $year]);
+        }
 
         /** @var VacationRequest $vacationRequestApproved */
         $vacationRequestApproved = VacationRequest::factory([
             "type" => VacationType::Vacation->value,
             "state" => Created::class,
-            "from" => Carbon::create($currentYearPeriod->year, 1, 31)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+            "from" => Carbon::create($year, 1, 31)->toDateString(),
+            "to" => Carbon::create($year, 2, 4)->toDateString(),
             "comment" => "Komentarz do wniosku urlopowego.",
         ])
             ->for($user)
             ->for($user, "creator")
-            ->for($currentYearPeriod)
             ->afterCreating(function (VacationRequest $vacationRequest): void {
                 $days = app(WorkDaysCalculator::class)->calculateDays(
                     $vacationRequest->from,
@@ -243,7 +222,6 @@ public function run(): void
                     $vacationRequest->vacations()->create([
                         "date" => $day,
                         "user_id" => $vacationRequest->user->id,
-                        "year_period_id" => $vacationRequest->yearPeriod->id,
                     ]);
                 }
             })
@@ -295,13 +273,12 @@ public function run(): void
         $vacationRequestWaitsForAdminApproval = VacationRequest::factory([
             "type" => VacationType::Vacation->value,
             "state" => Created::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 14)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 14)->toDateString(),
+            "from" => Carbon::create($year, 2, 14)->toDateString(),
+            "to" => Carbon::create($year, 2, 14)->toDateString(),
             "comment" => "Komentarz do wniosku urlopowego.",
         ])
             ->for($user)
             ->for($user, "creator")
-            ->for($currentYearPeriod)
             ->afterCreating(function (VacationRequest $vacationRequest): void {
                 $days = app(WorkDaysCalculator::class)->calculateDays(
                     $vacationRequest->from,
@@ -313,7 +290,6 @@ public function run(): void
                     $vacationRequest->vacations()->create([
                         "date" => $day,
                         "user_id" => $vacationRequest->user->id,
-                        "year_period_id" => $vacationRequest->yearPeriod->id,
                     ]);
                 }
             })
@@ -354,13 +330,12 @@ public function run(): void
         $vacationRequestRejected = VacationRequest::factory([
             "type" => VacationType::Vacation->value,
             "state" => Created::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
+            "from" => Carbon::create($year, 2, 7)->toDateString(),
+            "to" => Carbon::create($year, 2, 7)->toDateString(),
             "comment" => "",
         ])
             ->for($user)
             ->for($user, "creator")
-            ->for($currentYearPeriod)
             ->afterCreating(function (VacationRequest $vacationRequest): void {
                 $days = app(WorkDaysCalculator::class)->calculateDays(
                     $vacationRequest->from,
@@ -372,7 +347,6 @@ public function run(): void
                     $vacationRequest->vacations()->create([
                         "date" => $day,
                         "user_id" => $vacationRequest->user->id,
-                        "year_period_id" => $vacationRequest->yearPeriod->id,
                     ]);
                 }
             })
diff --git a/package-lock.json b/package-lock.json
index 08b070a6..9d552085 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,5 +1,5 @@
 {
-    "name": "toby",
+    "name": "application",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
diff --git a/resources/js/Composables/yearPeriodInfo.js b/resources/js/Composables/yearPeriodInfo.js
deleted file mode 100644
index ede213c9..00000000
--- a/resources/js/Composables/yearPeriodInfo.js
+++ /dev/null
@@ -1,14 +0,0 @@
-import { computed } from 'vue'
-import { usePage } from '@inertiajs/inertia-vue3'
-
-export default function useCurrentYearPeriodInfo() {
-  const minDate = computed(() => new Date(usePage().props.value.years.selected.year, 0, 1))
-  const maxDate = computed(() => new Date(usePage().props.value.years.selected.year, 11, 31))
-  const year = computed(() => usePage().props.value.years.selected.year)
-
-  return {
-    minDate,
-    maxDate,
-    year,
-  }
-}
diff --git a/resources/js/Pages/AnnualSummary.vue b/resources/js/Pages/AnnualSummary.vue
index ca75bde6..c45c5430 100644
--- a/resources/js/Pages/AnnualSummary.vue
+++ b/resources/js/Pages/AnnualSummary.vue
@@ -1,12 +1,28 @@
 <script setup>
 import CalendarComponent from '@/Shared/CalendarComponent.vue'
+import YearPicker from '@/Shared/Forms/YearPicker.vue'
+import { ref, watch } from 'vue'
+import { DateTime } from 'luxon'
+import { Inertia } from '@inertiajs/inertia'
 
-defineProps({
+const props = defineProps({
+  year: Number,
   holidays: Object,
   vacations: Object,
   pendingVacations: Object,
   overButtonDay: String,
 })
+const currentDate = DateTime.now()
+const selectedYear = ref(props.year)
+
+watch(selectedYear, (value, oldValue) => {
+  if (value === oldValue)
+    return
+
+  Inertia.visit('/vacation/annual-summary', {
+    data: { year: value },
+  })
+})
 </script>
 
 <template>
@@ -15,12 +31,19 @@ defineProps({
     <div class="p-4 sm:px-6">
       <h2 class="text-lg font-medium leading-6 text-gray-900">
         Podsumowanie roczne
+        <YearPicker
+          v-model="selectedYear"
+          :from="currentDate.year - 20"
+          :to="currentDate.year + 1"
+          class="inline-block ml-2"
+        />
       </h2>
     </div>
     <div
       class="grid grid-cols-1 gap-8 py-8 px-4 mx-auto max-w-3xl border-t border-gray-200 sm:grid-cols-2 sm:px-6 xl:grid-cols-3 xl:px-8 xl:max-w-none 2xl:grid-cols-4"
     >
       <CalendarComponent
+        :year="year"
         :start-month="1"
         :end-month="12"
         :vacations="vacations"
diff --git a/resources/js/Pages/AssignedBenefits/AssignedBenefits.vue b/resources/js/Pages/AssignedBenefits/AssignedBenefits.vue
index d61c723d..48b857ea 100644
--- a/resources/js/Pages/AssignedBenefits/AssignedBenefits.vue
+++ b/resources/js/Pages/AssignedBenefits/AssignedBenefits.vue
@@ -1,11 +1,11 @@
 <script setup>
-import { useMonthInfo } from '@/Composables/monthInfo.js'
 import { Dialog, DialogOverlay, DialogTitle, TransitionChild, TransitionRoot } from '@headlessui/vue'
 import TextArea from '@/Shared/Forms/TextArea.vue'
-import { computed, ref, watch } from 'vue'
+import { ref, watch } from 'vue'
 import { useForm } from '@inertiajs/inertia-vue3'
 import { debounce } from 'lodash'
 import UserProfileLink from '@/Shared/UserProfileLink.vue'
+import { DateTime } from 'luxon'
 
 const props = defineProps({
   current: String,
@@ -13,13 +13,12 @@ const props = defineProps({
   benefits: Object,
   benefitsReports: Object,
   assignedBenefits: Object,
-  years: Object,
   auth: Object,
 })
 
+const currentDate = DateTime.now()
+
 const creatingBenefitsReport = ref(false)
-const { findMonth } = useMonthInfo()
-const currentMonth = computed(() => findMonth(props.current))
 
 const form = useForm({
   items: props.users.data.map((user) => {
@@ -70,7 +69,9 @@ function submitAssignedBenefits() {
 }
 
 function startCreatingBenefitsReport() {
-  formBenefitsReport.name = `${currentMonth.value.name} ${props.years.selected.year}`
+  const name = currentDate.toLocaleString({ month: 'long', year: 'numeric' })
+
+  formBenefitsReport.name = name.at(0).toUpperCase() + name.slice(1)
   creatingBenefitsReport.value = true
 }
 
@@ -125,8 +126,8 @@ function isBenefitHasCompanion(benefitId) {
                 class="py-2 w-64 text-lg font-semibold text-gray-800 sticky left-0 bg-white outline outline-1 outline-offset-0 outline-gray-300"
                 rowspan="2"
               >
-                <div class="flex justify-center items-center">
-                  {{ currentMonth.name }} {{ years.selected.year }}
+                <div class="flex justify-center items-center capitalize">
+                  {{ currentDate.toLocaleString({ month: 'long', year: 'numeric' }) }}
                 </div>
               </th>
               <th
diff --git a/resources/js/Pages/Calendar.vue b/resources/js/Pages/Calendar.vue
index ec8f7ab2..c3e916ee 100644
--- a/resources/js/Pages/Calendar.vue
+++ b/resources/js/Pages/Calendar.vue
@@ -1,54 +1,50 @@
 <script setup>
 import {
   ArrowUturnLeftIcon,
-  ChevronDoubleLeftIcon,
-  ChevronDoubleRightIcon,
   ChevronLeftIcon,
   ChevronRightIcon,
-  ChevronUpDownIcon,
 } from '@heroicons/vue/24/solid'
-import { computed, ref, watch } from 'vue'
-import { useMonthInfo } from '@/Composables/monthInfo.js'
+import { ref, watch } from 'vue'
 import VacationTypeCalendarIcon from '@/Shared/VacationTypeCalendarIcon.vue'
 import CalendarDay from '@/Shared/CalendarDay.vue'
 import UserProfileLink from '@/Shared/UserProfileLink.vue'
-import { Listbox, ListboxButton, ListboxOption, ListboxOptions } from '@headlessui/vue'
-import { useForm } from '@inertiajs/inertia-vue3'
 import { Inertia } from '@inertiajs/inertia'
+import { DateTime } from 'luxon'
+import MonthPicker from '@/Shared/Forms/MonthPicker.vue'
 
 const props = defineProps({
   users: Object,
   auth: Object,
   calendar: Object,
   workingHours: Number,
-  currentMonth: String,
-  currentYear: Number,
-  selectedMonth: String,
-  selectedYear: Number,
-  years: Object,
-  previousYearPeriod: Object,
-  nextYearPeriod: Object,
+  selectedDate: String,
 })
 
 let activeElement = ref(undefined)
 
-const { getMonths, findMonth } = useMonthInfo()
+const currentDate = DateTime.now()
 
-const months = getMonths()
+const selectedMonth = ref(DateTime.fromISO(props.selectedDate))
 
-const form = useForm({
-  selectedMonth: months.find(month => month.value === props.selectedMonth),
-})
-
-watch(() => form.selectedMonth, (value) => {
-  if (value) {
-    Inertia.visit(`/calendar/${value.value}`)
+watch(selectedMonth, (value, oldValue) => {
+  if (!value || value.toFormat('LL-YYY') === oldValue?.toFormat('LL-YYY')) {
+    return
   }
+
+  Inertia.visit(`/calendar/${value.toFormat('LL-yyyy')}`)
 })
 
-const selectedMonth = computed(() => findMonth(props.selectedMonth))
-const previousMonth = computed(() => months[months.indexOf(selectedMonth.value) - 1])
-const nextMonth = computed(() => months[months.indexOf(selectedMonth.value) + 1])
+function previousMonth() {
+  selectedMonth.value = selectedMonth.value.minus({ month: 1 })
+}
+
+function nextMonth() {
+  selectedMonth.value = selectedMonth.value.plus({ month: 1 })
+}
+
+function currentMonth() {
+  selectedMonth.value = currentDate
+}
 
 function isActiveDay(key) {
   return activeElement.value === key
@@ -81,121 +77,53 @@ function linkVacationRequest(user) {
           Kalendarz
         </h2>
         <div class="flex items-center sm:ml-3 md:items-stretch">
-          <InertiaLink
-            v-if="previousMonth"
-            :href="`/calendar/${previousMonth.value}`"
-            as="button"
+          <button
+            type="button"
             class="flex focus:relative justify-center items-center p-2 text-gray-400 hover:text-gray-500 bg-white rounded-l-md border border-r-0 border-gray-300 md:px-2 md:w-9 md:hover:bg-gray-50"
+            @click="previousMonth()"
           >
             <ChevronLeftIcon class="w-5 h-5" />
-          </InertiaLink>
-          <InertiaLink
-            v-else-if="previousYearPeriod"
-            :href="`/calendar/${months[11].value}/${previousYearPeriod.year}`"
-            as="button"
-            class="flex focus:relative justify-center items-center p-2 text-gray-400 hover:text-gray-500 bg-white rounded-l-md border border-r-0 border-gray-300 md:px-2 md:w-9 md:hover:bg-gray-50"
-          >
-            <ChevronDoubleLeftIcon class="w-5 h-5" />
-          </InertiaLink>
-          <span
-            v-else
-            class="flex justify-center items-center text-gray-400 bg-gray-100 rounded-l-md border border-r-0 border-gray-300 md:px-2 md:w-9"
-          >
-            <ChevronDoubleLeftIcon class="w-5 h-5" />
-          </span>
-          <Listbox
-            v-model="form.selectedMonth"
-            as="div"
-            class="items-center grid-cols-3 w-[135px] h-[] text-sm font-medium text-gray-700 hover:text-gray-900 bg-white hover:bg-gray-50 border-y border-gray-300 focus:outline-blumilk-500"
-          >
-            <div class="relative sm:col-span-2 sm:mt-0">
-              <ListboxButton
-                class="relative pr-10 pl-3 w-full h-[36px] max-w-lg text-left bg-white focus:outline-none shadow-sm sm:text-sm cursor-pointer"
-              >
-                <template v-if="form.selectedMonth">
-                  <span class="block truncate text-center">
-                    {{ form.selectedMonth.name }}
-                  </span>
-                  <span class="flex absolute inset-y-0 right-0 items-center pr-2 pointer-events-none">
-                    <ChevronUpDownIcon class="w-5 h-5 text-gray-400" />
-                  </span>
-                </template>
-              </ListboxButton>
-              <transition
-                leave-active-class="transition ease-in duration-100"
-                leave-from-class="opacity-100"
-                leave-to-class="opacity-0"
-              >
-                <ListboxOptions
-                  class="overflow-auto absolute z-10 py-1 mt-1 w-auto max-w-lg max-h-60 text-base bg-white rounded-md focus:outline-none ring-1 ring-black ring-opacity-5 shadow-lg sm:text-sm"
-                >
-                  <ListboxOption
-                    v-for="month in months"
-                    :key="month.value"
-                    v-slot="{ active, selected }"
-                    :value="month"
-                    as="template"
-                  >
-                    <li :class="[active ? 'bg-gray-100' : 'text-gray-900', 'cursor-default select-none relative py-2 pl-3 pr-9 cursor-pointer']">
-                      <span :class="[selected ? 'font-semibold' : 'font-normal', 'block truncate']">
-                        {{ month.name }}
-                      </span>
-                    </li>
-                  </ListboxOption>
-                </ListboxOptions>
-              </transition>
-            </div>
-          </Listbox>
-          <InertiaLink
-            v-if="nextMonth"
-            :href="`/calendar/${nextMonth.value}`"
-            as="button"
+          </button>
+          <MonthPicker
+            :model-value="selectedMonth.toFormat('LL-yyyy')"
+            class="block w-40 shadow-sm disabled:bg-gray-100 focus:ring-blumilk-500 focus:border-blumilk-500 sm:text-sm border-gray-300"
+            @update:model-value="selectedMonth = DateTime.fromFormat($event, 'LL/yyyy')"
+          />
+          <button
+            type="button"
             class="flex focus:relative justify-center items-center p-2 text-gray-400 hover:text-gray-500 bg-white rounded-r-md border border-l-0 border-gray-300 focus:outline-blumilk-500 md:px-2 md:w-9 md:hover:bg-gray-50"
+            @click="nextMonth()"
           >
             <ChevronRightIcon class="w-5 h-5" />
-          </InertiaLink>
-          <InertiaLink
-            v-else-if="nextYearPeriod"
-            :href="`/calendar/${months[0].value}/${nextYearPeriod.year}`"
-            as="button"
-            class="flex focus:relative justify-center items-center p-2 text-gray-400 hover:text-gray-500 bg-white rounded-r-md border border-l-0 border-gray-300 focus:outline-blumilk-500 md:px-2 md:w-9 md:hover:bg-gray-50"
-          >
-            <ChevronDoubleRightIcon class="w-5 h-5" />
-          </InertiaLink>
-          <span
-            v-else
-            class="flex justify-center items-center text-gray-400 bg-gray-100 rounded-r-md border border-l-0 border-gray-300 md:px-2 md:w-9"
-          >
-            <ChevronDoubleRightIcon class="w-5 h-5" />
-          </span>
-          <InertiaLink
-            v-if="selectedMonth.value !== currentMonth || currentYear !== selectedYear"
-            :href="`/calendar/${props.currentMonth}/${props.currentYear}`"
-            as="button"
+          </button>
+          <button
+            v-if="selectedMonth.toFormat('LL-yyyy') !== currentDate.toFormat('LL-yyyy')"
+            type="button"
             class="flex focus:relative justify-center items-center p-2 bg-white md:px-2 md:hover:bg-gray-50 ml-1"
+            @click="currentMonth()"
           >
             <ArrowUturnLeftIcon class="w-5 h-5 text-blumilk-600 hover:text-blumilk-500" />
             <span class="ml-1.5 text-sm font-semibold text-blumilk-600 hover:text-blumilk-500">
               Dzisiaj
             </span>
-          </InertiaLink>
+          </button>
         </div>
       </div>
       <div class="flex-row">
         <div
-          class="flex items-center mt-3 sm:mt-0"
+          class="flex items-center justify-end gap-3 mt-3 sm:mt-0"
         >
           <a
             v-if="auth.can.manageRequestsAsAdministrativeApprover"
-            :href="`/vacation/timesheet/${selectedMonth.value}`"
-            class="block py-3 px-4 sm:ml-3 text-sm font-medium leading-4 text-center text-white bg-blumilk-600 hover:bg-blumilk-700 rounded-md border border-transparent focus:outline-none focus:ring-2 focus:ring-blumilk-500 focus:ring-offset-2 shadow-sm"
+            :href="`/vacation/timesheet/${selectedMonth.toFormat('LL-yyyy')}`"
+            class="block py-3 px-4 text-sm font-medium leading-4 text-center text-white bg-blumilk-600 hover:bg-blumilk-700 rounded-md border border-transparent focus:outline-none focus:ring-2 focus:ring-blumilk-500 focus:ring-offset-2 shadow-sm"
           >
             Pobierz plik Excel
           </a>
           <a
             v-if="auth.can.manageOvertimeAsAdministrativeApprover"
-            :href="`/overtime/timesheet/${selectedMonth.value}`"
-            class="block py-3 px-4 ml-3 text-sm font-medium leading-4 text-center text-white bg-blumilk-600 hover:bg-blumilk-700 rounded-md border border-transparent focus:outline-none focus:ring-2 focus:ring-blumilk-500 focus:ring-offset-2 shadow-sm"
+            :href="`/overtime/timesheet/${selectedMonth.toFormat('LL-yyyy')}`"
+            class="block py-3 px-4 text-sm font-medium leading-4 text-center text-white bg-blumilk-600 hover:bg-blumilk-700 rounded-md border border-transparent focus:outline-none focus:ring-2 focus:ring-blumilk-500 focus:ring-offset-2 shadow-sm"
           >
             Pobierz nadgodziny
           </a>
@@ -215,8 +143,8 @@ function linkVacationRequest(user) {
         <thead>
           <tr>
             <th class="py-2 w-64 text-lg font-semibold text-gray-800 border border-gray-300">
-              <div class="flex justify-center items-center">
-                {{ selectedMonth.name }} {{ years.selected.year }}
+              <div class="flex justify-center items-center capitalize">
+                {{ selectedMonth.toLocaleString({ month: 'long', year: 'numeric' }) }}
               </div>
             </th>
             <th
diff --git a/resources/js/Pages/Dashboard.vue b/resources/js/Pages/Dashboard.vue
index 98e03b38..912e8a7e 100644
--- a/resources/js/Pages/Dashboard.vue
+++ b/resources/js/Pages/Dashboard.vue
@@ -17,7 +17,6 @@ defineProps({
   vacationRequests: Object,
   stats: Object,
   calendar: Object,
-  years: Object,
   benefits: Object,
 })
 </script>
@@ -56,7 +55,6 @@ defineProps({
         :birthdays="upcoming.birthdays.data"
       />
       <UpcomingHolidays
-        v-if="years.current.year === years.selected.year && upcoming.holidays.data.length"
         :holidays="upcoming.holidays.data"
       />
       <BenefitList
diff --git a/resources/js/Pages/Equipment/Create.vue b/resources/js/Pages/Equipment/Create.vue
index 587fcc07..6c7d4b9f 100644
--- a/resources/js/Pages/Equipment/Create.vue
+++ b/resources/js/Pages/Equipment/Create.vue
@@ -115,9 +115,6 @@ function createEquipmentItem() {
       >
         <ListboxLabel class="block text-sm font-medium text-gray-700">
           Przydzielona osoba
-          <span class="text-xs text-gray-500">
-            (opcjonalna)
-          </span>
         </ListboxLabel>
         <div class="relative mt-1 sm:col-span-2 sm:mt-0">
           <ListboxButton
diff --git a/resources/js/Pages/Equipment/Edit.vue b/resources/js/Pages/Equipment/Edit.vue
index 5bb761c2..dfcfd5d6 100644
--- a/resources/js/Pages/Equipment/Edit.vue
+++ b/resources/js/Pages/Equipment/Edit.vue
@@ -116,9 +116,6 @@ function editEquipmentItem() {
       >
         <ListboxLabel class="block text-sm font-medium text-gray-700">
           Przydzielona osoba
-          <span class="text-xs text-gray-500">
-            (opcjonalna)
-          </span>
         </ListboxLabel>
         <div class="relative mt-1 sm:col-span-2 sm:mt-0">
           <ListboxButton
diff --git a/resources/js/Pages/Holidays/Create.vue b/resources/js/Pages/Holidays/Create.vue
index c7e86f26..a5f043fa 100644
--- a/resources/js/Pages/Holidays/Create.vue
+++ b/resources/js/Pages/Holidays/Create.vue
@@ -1,15 +1,12 @@
 <script setup>
 import { useForm } from '@inertiajs/inertia-vue3'
 import FlatPickr from 'vue-flatpickr-component'
-import useCurrentYearPeriodInfo from '@/Composables/yearPeriodInfo.js'
 
 const form = useForm({
   name: null,
   date: null,
 })
 
-const { minDate, maxDate } = useCurrentYearPeriodInfo()
-
 function createHoliday() {
   form.post('/holidays')
 }
@@ -61,7 +58,6 @@ function createHoliday() {
           <FlatPickr
             id="date"
             v-model="form.date"
-            :config="{minDate, maxDate}"
             class="block w-full max-w-lg rounded-md shadow-sm sm:text-sm"
             :class="{ 'border-red-300 text-red-900 focus:outline-none focus:ring-red-500 focus:border-red-500': form.errors.date, 'focus:ring-blumilk-500 focus:border-blumilk-500 sm:text-sm border-gray-300': !form.errors.date }"
           />
diff --git a/resources/js/Pages/Holidays/Index.vue b/resources/js/Pages/Holidays/Index.vue
index bd0a9f2e..44c59845 100644
--- a/resources/js/Pages/Holidays/Index.vue
+++ b/resources/js/Pages/Holidays/Index.vue
@@ -3,10 +3,27 @@ import { EllipsisVerticalIcon, PencilIcon, TrashIcon } from '@heroicons/vue/24/s
 import { FlagIcon } from '@heroicons/vue/24/outline'
 import { Menu, MenuButton, MenuItem, MenuItems } from '@headlessui/vue'
 import EmptyState from '@/Shared/Feedbacks/EmptyState.vue'
+import YearPicker from '@/Shared/Forms/YearPicker.vue'
+import { ref, watch } from 'vue'
+import { Inertia } from '@inertiajs/inertia'
+import { DateTime } from 'luxon'
 
-defineProps({
+const props = defineProps({
   holidays: Object,
   auth: Object,
+  year: Number,
+})
+
+const selectedYear = ref(props.year)
+const currentDate = DateTime.now()
+
+watch(selectedYear, (value, oldValue) => {
+  if (value === oldValue)
+    return
+
+  Inertia.visit('/holidays', {
+    data: { year: value },
+  })
 })
 </script>
 
@@ -16,7 +33,13 @@ defineProps({
     <div class="flex justify-between items-center p-4 sm:px-6">
       <div>
         <h2 class="text-lg font-medium leading-6 text-gray-900">
-          Dni wolne od pracy
+          Dni wolne od pracy w roku
+          <YearPicker
+            v-model="selectedYear"
+            :from="currentDate.year + 1"
+            :to="currentDate.year - 20"
+            class="inline-block ml-2"
+          />
         </h2>
       </div>
       <div v-if="auth.can.manageHolidays">
diff --git a/resources/js/Pages/MonthlyUsage.vue b/resources/js/Pages/MonthlyUsage.vue
index b39a303e..b4b68c12 100644
--- a/resources/js/Pages/MonthlyUsage.vue
+++ b/resources/js/Pages/MonthlyUsage.vue
@@ -2,19 +2,35 @@
 import { useMonthInfo } from '@/Composables/monthInfo.js'
 import VacationBar from '@/Shared/VacationBar.vue'
 import UserProfileLink from '@/Shared/UserProfileLink.vue'
+import { ref, watch } from 'vue'
+import { DateTime } from 'luxon'
+import { Inertia } from '@inertiajs/inertia'
+import YearPicker from '@/Shared/Forms/YearPicker.vue'
 
 const props = defineProps({
-  years: Object,
+  year: Number,
   monthlyUsage: Object,
   currentMonth: String,
 })
 
+const selectedYear = ref(props.year)
+const currentDate = DateTime.now()
+
 const { getMonths } = useMonthInfo()
 const months = getMonths()
 
 function isCurrentMonth(month) {
-  return (props.years.selected.year === props.years.current.year && props.currentMonth === month.value)
+  return (props.year === currentDate.year && props.currentMonth === month.value)
 }
+
+watch(selectedYear, (value, oldValue) => {
+  if (value === oldValue)
+    return
+
+  Inertia.visit('/vacation/monthly-usage', {
+    data: { year: value },
+  })
+})
 </script>
 
 <template>
@@ -23,7 +39,13 @@ function isCurrentMonth(month) {
     <div class="flex justify-between items-center p-4 sm:px-6">
       <div class="flex items-center">
         <h2 class="text-lg font-medium leading-6 text-gray-900">
-          Wykorzystanie miesięczne urlopu
+          Wykorzystanie miesięczne urlopu w roku
+          <YearPicker
+            v-model="selectedYear"
+            :from="currentDate.year + 1"
+            :to="currentDate.year - 20"
+            class="inline-block ml-2"
+          />
         </h2>
       </div>
     </div>
@@ -94,6 +116,14 @@ function isCurrentMonth(month) {
                 </div>
               </td>
             </tr>
+            <tr v-if="!monthlyUsage.length">
+              <td
+                class="py-4 text-xl leading-5 text-center text-gray-700"
+                colspan="100%"
+              >
+                Brak danych
+              </td>
+            </tr>
           </tbody>
         </table>
       </div>
diff --git a/resources/js/Pages/OvertimeRequest/Create.vue b/resources/js/Pages/OvertimeRequest/Create.vue
index 045a24c7..7ea0a285 100644
--- a/resources/js/Pages/OvertimeRequest/Create.vue
+++ b/resources/js/Pages/OvertimeRequest/Create.vue
@@ -3,7 +3,6 @@ import { useForm } from '@inertiajs/inertia-vue3'
 import FlatPickr from 'vue-flatpickr-component'
 import { CheckIcon, ChevronUpDownIcon, XCircleIcon } from '@heroicons/vue/24/solid'
 import { reactive, ref, watch } from 'vue'
-import useCurrentYearPeriodInfo from '@/Composables/yearPeriodInfo.js'
 import { Listbox, ListboxButton, ListboxLabel, ListboxOption, ListboxOptions } from '@headlessui/vue'
 import SettlementType from '@/Shared/SettlementType.vue'
 import axios from 'axios'
@@ -33,19 +32,13 @@ refreshEstimatedHours(form.from, form.to)
 
 const estimatedHours = ref(0)
 
-const { minDate, maxDate } = useCurrentYearPeriodInfo()
-
 const fromInputConfig = reactive({
-  minDate,
-  maxDate,
   enableTime: true,
   dateFormat: 'Y-m-d H:i',
   altFormat: 'd.m.Y H:i',
 })
 
 const toInputConfig = reactive({
-  minDate,
-  maxDate,
   enableTime: true,
   dateFormat: 'Y-m-d H:i',
   altFormat: 'd.m.Y H:i',
@@ -65,15 +58,13 @@ function onFromChange(selectedDates, dateStr) {
   if (form.to === null) {
     form.to = dateStr
 
-    return
+
   }
 }
 
 function onToChange(selectedDates, dateStr) {
   if (form.from === null) {
     form.from = dateStr
-
-    return
   }
 }
 
diff --git a/resources/js/Pages/OvertimeRequest/Index.vue b/resources/js/Pages/OvertimeRequest/Index.vue
index a01b92a3..5fb108f1 100644
--- a/resources/js/Pages/OvertimeRequest/Index.vue
+++ b/resources/js/Pages/OvertimeRequest/Index.vue
@@ -8,6 +8,8 @@ import { debounce } from 'lodash'
 import { Inertia } from '@inertiajs/inertia'
 import EmptyState from '@/Shared/Feedbacks/EmptyState.vue'
 import SettlementType from '@/Shared/SettlementType.vue'
+import YearPicker from '@/Shared/Forms/YearPicker.vue'
+import { DateTime } from 'luxon'
 
 const props = defineProps({
   requests: Object,
@@ -15,6 +17,8 @@ const props = defineProps({
   filters: Object,
 })
 
+const currentDate = DateTime.now()
+
 const statuses = [
   {
     name: 'Wszystkie',
@@ -40,10 +44,11 @@ const statuses = [
 
 const form = reactive({
   status: statuses.find(status => status.value === props.filters.status) ?? statuses[0],
+  year: props.filters.year,
 })
 
 watch(form, debounce(() => {
-  Inertia.get('/overtime/requests/me', { status: form.status.value, withoutRemote: form.withoutRemote }, {
+  Inertia.get('/overtime/requests/me', { status: form.status.value, year: form.year }, {
     preserveState: true,
     replace: false,
   })
@@ -56,7 +61,13 @@ watch(form, debounce(() => {
   <div class="bg-white shadow-md">
     <div class="flex justify-between items-center p-4 sm:px-6">
       <h2 class="text-lg font-medium leading-6 text-gray-900">
-        Moje nadgodziny
+        Moje nadgodziny w roku
+        <YearPicker
+          v-model="form.year"
+          :from="currentDate.year + 1"
+          :to="currentDate.year - 20"
+          class="inline-block ml-2"
+        />
       </h2>
       <div>
         <InertiaLink
diff --git a/resources/js/Pages/OvertimeRequest/IndexForApprovers.vue b/resources/js/Pages/OvertimeRequest/IndexForApprovers.vue
index 9e349180..25b095f2 100644
--- a/resources/js/Pages/OvertimeRequest/IndexForApprovers.vue
+++ b/resources/js/Pages/OvertimeRequest/IndexForApprovers.vue
@@ -8,6 +8,8 @@ import { Listbox, ListboxButton, ListboxLabel, ListboxOption, ListboxOptions } f
 import Pagination from '@/Shared/Pagination.vue'
 import EmptyState from '@/Shared/Feedbacks/EmptyState.vue'
 import SettlementType from '@/Shared/SettlementType.vue'
+import { DateTime } from 'luxon'
+import YearPicker from '@/Shared/Forms/YearPicker.vue'
 
 const props = defineProps({
   auth: Object,
@@ -16,6 +18,8 @@ const props = defineProps({
   filters: Object,
 })
 
+const currentDate = DateTime.now()
+
 const statuses = [
   {
     name: 'Wszystkie',
@@ -46,12 +50,14 @@ const statuses = [
 const form = reactive({
   user: props.users.data.find(user => user.id === props.filters.user) ?? null,
   status: statuses.find(status => status.value === props.filters.status) ?? statuses[0],
+  year: props.filters.year ?? null,
 })
 
 watch(form, debounce(() => {
   Inertia.get('/overtime/requests', {
     user: form.user?.id,
     status: form.status.value,
+    year: form.year,
   }, {
     preserveState: true,
     replace: true,
@@ -218,6 +224,14 @@ watch(form, debounce(() => {
             </transition>
           </div>
         </Listbox>
+        <YearPicker
+          v-model="form.year"
+          nullable
+          label="Rok"
+          :from="currentDate.year + 1"
+          :to="currentDate.year - 20"
+          class="inline-block ml-2"
+        />
       </div>
     </div>
     <div class="overflow-auto xl:overflow-visible">
diff --git a/resources/js/Pages/VacationLimits.vue b/resources/js/Pages/VacationLimits.vue
index 5452a19c..857a2d81 100644
--- a/resources/js/Pages/VacationLimits.vue
+++ b/resources/js/Pages/VacationLimits.vue
@@ -6,24 +6,32 @@ import VacationLimitPopup from '@/Shared/VacationLimitPopup.vue'
 import RemainingFromPreviousYearPopup from '@/Shared/RemainingFromPreviousYearPopup.vue'
 import TakeVacationDaysFromPreviousYearModal from '@/Shared/Modals/TakeVacationDaysFromPreviousYearModal.vue'
 import UserProfileLink from '@/Shared/UserProfileLink.vue'
+import { Inertia } from '@inertiajs/inertia'
+import { DateTime } from 'luxon'
+import YearPicker from '@/Shared/Forms/YearPicker.vue'
 
 const props = defineProps({
   limits: Object,
-  years: Object,
+  year: Number,
 })
 
 const form = useForm({
   items: props.limits,
 })
 
+const currentDate = DateTime.now()
+
 const takingDaysFromPreviousYear = ref(false)
 const limitToChange = ref(null)
 
+const selectedYear = ref(props.year)
+
 function submitVacationDays() {
   form
     .transform(data => ({
       items: data.items.map(item => ({
-        id: item.id,
+        user: item.user.id,
+        year: props.year,
         days: item.hasVacation ? item.days : null,
       })),
     }))
@@ -39,6 +47,15 @@ watch(() => form.items, () => {
   }
 
 }, { deep: true })
+
+watch(selectedYear, (value, oldValue) => {
+  if (value === oldValue)
+    return
+
+  Inertia.visit('/vacation/limits', {
+    data: { year: value },
+  })
+})
 </script>
 
 <template>
@@ -47,7 +64,13 @@ watch(() => form.items, () => {
     <div class="flex justify-between items-center p-4 sm:px-6">
       <div>
         <h2 class="text-lg font-medium leading-6 text-gray-900">
-          Limit dni urlopu dla użytkowników
+          Limit urlopu dla użytkowników w roku
+          <YearPicker
+            v-model="selectedYear"
+            :from="currentDate.year + 1"
+            :to="currentDate.year - 20"
+            class="inline-block ml-2"
+          />
         </h2>
       </div>
     </div>
@@ -79,19 +102,19 @@ watch(() => form.items, () => {
                   class="py-3 px-4 text-xs font-semibold tracking-wider text-left text-gray-500 uppercase whitespace-nowrap"
                   scope="col"
                 >
-                  Pozostałe dni z {{ years.selected.year - 1 }}
+                  Pozostałe dni z {{ year - 1 }}
                 </th>
                 <th
                   class="py-3 px-4 text-xs font-semibold tracking-wider text-left text-gray-500 uppercase whitespace-nowrap"
                   scope="col"
                 >
-                  Przysługujące dni w roku {{ years.selected.year }}
+                  Przysługujące dni w roku {{ year }}
                 </th>
                 <th
                   class="py-3 px-4 text-xs font-semibold tracking-wider text-left text-gray-500 uppercase whitespace-nowrap"
                   scope="col"
                 >
-                  Łączny limit na rok {{ years.selected.year }}
+                  Łączny limit na rok {{ year }}
                 </th>
               </tr>
             </thead>
@@ -140,7 +163,7 @@ watch(() => form.items, () => {
                   <RemainingFromPreviousYearPopup
                     :remaining="item.remainingLastYear"
                     :to-next-year="item.fromPreviousYear"
-                    :year="years.selected.year - 1"
+                    :year="year"
                     class="w-full"
                     @change-previous-year="limitToChange = item; takingDaysFromPreviousYear = true"
                   >
@@ -175,7 +198,7 @@ watch(() => form.items, () => {
                     :from-previous-year="item.fromPreviousYear"
                     :limit="item.limit"
                     :to-next-year="item.toNextYear"
-                    :year="years.selected.year"
+                    :year="year"
                     class="w-full"
                   >
                     <div
@@ -213,7 +236,7 @@ watch(() => form.items, () => {
   <TakeVacationDaysFromPreviousYearModal
     :limit="limitToChange"
     :show="takingDaysFromPreviousYear"
-    :year="years.selected.year - 1"
+    :year="year"
     @changed="takingDaysFromPreviousYear = false"
     @close="takingDaysFromPreviousYear = false"
   />
diff --git a/resources/js/Pages/VacationRequest/Create.vue b/resources/js/Pages/VacationRequest/Create.vue
index 2931bde3..626e1873 100644
--- a/resources/js/Pages/VacationRequest/Create.vue
+++ b/resources/js/Pages/VacationRequest/Create.vue
@@ -3,11 +3,11 @@ import { useForm } from '@inertiajs/inertia-vue3'
 import FlatPickr from 'vue-flatpickr-component'
 import { Listbox, ListboxButton, ListboxLabel, ListboxOption, ListboxOptions, Switch } from '@headlessui/vue'
 import { CheckIcon, ChevronUpDownIcon, XCircleIcon } from '@heroicons/vue/24/solid'
-import { reactive, ref, watch } from 'vue'
+import { computed, reactive, ref, watch } from 'vue'
 import axios from 'axios'
-import useCurrentYearPeriodInfo from '@/Composables/yearPeriodInfo.js'
 import VacationChart from '@/Shared/VacationChart.vue'
 import VacationType from '@/Shared/VacationType.vue'
+import { DateTime } from 'luxon'
 
 const props = defineProps({
   auth: Object,
@@ -29,6 +29,7 @@ const form = useForm({
 })
 
 let isDirty = ref(false)
+const currentDate = DateTime.now()
 
 watch(form, formData => {
   const { from, to } = formData.data()
@@ -46,17 +47,15 @@ const stats = ref({
   remaining: 0,
 })
 
-const { minDate, maxDate } = useCurrentYearPeriodInfo()
-
-const fromInputConfig = reactive({
-  minDate,
-  maxDate,
+const year = computed(() => {
+  return form.from === null
+    ? currentDate.year
+    : DateTime.fromISO(form.from).year
 })
 
-const toInputConfig = reactive({
-  minDate,
-  maxDate,
-})
+const fromInputConfig = reactive({})
+
+const toInputConfig = reactive({})
 
 watch(() => form.user, user => {
   resetForm()
@@ -70,6 +69,13 @@ watch(() => form.vacationType, vacationType => {
   refreshUnavailableDays(form.user, vacationType)
 })
 
+watch(year, () => {
+  refreshEstimatedDays(form.from, form.to, form.vacationType)
+  refreshUnavailableDays(form.user, form.vacationType)
+  refreshVacationStats(form.user)
+})
+
+
 function createForm() {
   form
     .transform(data => ({
@@ -96,6 +102,7 @@ function onToChange(selectedDates, dateStr) {
 
     return
   }
+
   refreshEstimatedDays(form.from, form.to, form.vacationType)
 }
 
@@ -121,7 +128,7 @@ async function refreshEstimatedDays(from, to, vacationType) {
 }
 
 async function refreshVacationStats(user) {
-  const res = await axios.post('/api/vacation/calculate-stats', { user: user.id })
+  const res = await axios.post('/api/vacation/calculate-stats', { user: user.id, year: year.value })
 
   stats.value = res.data
 }
@@ -129,7 +136,7 @@ async function refreshVacationStats(user) {
 async function refreshUnavailableDays(user) {
   const res = await axios.post(
     '/api/vacation/calculate-unavailable-days',
-    { user: user.id, vacationType: form.vacationType?.value },
+    { user: user.id, vacationType: form.vacationType?.value, year: year.value },
   )
   const unavailableDays = res.data
 
@@ -474,6 +481,9 @@ async function refreshAvailableTypes(user) {
           <span v-else>
             Moje dane o urlopie
           </span>
+          <span>
+            w roku {{ year }}
+          </span>
         </h2>
       </div>
       <div class="px-6 pt-8 border-t border-gray-200">
diff --git a/resources/js/Pages/VacationRequest/Index.vue b/resources/js/Pages/VacationRequest/Index.vue
index 010f7918..f22ed7ff 100644
--- a/resources/js/Pages/VacationRequest/Index.vue
+++ b/resources/js/Pages/VacationRequest/Index.vue
@@ -8,6 +8,8 @@ import { reactive, watch } from 'vue'
 import { debounce } from 'lodash'
 import { Inertia } from '@inertiajs/inertia'
 import EmptyState from '@/Shared/Feedbacks/EmptyState.vue'
+import { DateTime } from 'luxon'
+import YearPicker from '@/Shared/Forms/YearPicker.vue'
 
 const props = defineProps({
   requests: Object,
@@ -15,6 +17,8 @@ const props = defineProps({
   filters: Object,
 })
 
+const currentDate = DateTime.now()
+
 const statuses = [
   {
     name: 'Wszystkie',
@@ -37,10 +41,11 @@ const statuses = [
 const form = reactive({
   status: statuses.find(status => status.value === props.filters.status) ?? statuses[0],
   withoutRemote: props.filters.withoutRemote ?? false,
+  year: props.filters.year,
 })
 
 watch(form, debounce(() => {
-  Inertia.get('/vacation/requests/me', { status: form.status.value, withoutRemote: form.withoutRemote }, {
+  Inertia.get('/vacation/requests/me', { status: form.status.value, year: form.year, withoutRemote: form.withoutRemote }, {
     preserveState: true,
     replace: false,
   })
@@ -53,7 +58,13 @@ watch(form, debounce(() => {
   <div class="bg-white shadow-md">
     <div class="flex justify-between items-center p-4 sm:px-6">
       <h2 class="text-lg font-medium leading-6 text-gray-900">
-        Moje wnioski
+        Moje wnioski w roku
+        <YearPicker
+          v-model="form.year"
+          :from="currentDate.year + 1"
+          :to="currentDate.year - 20"
+          class="inline-block ml-2"
+        />
       </h2>
       <div>
         <InertiaLink
diff --git a/resources/js/Pages/VacationRequest/IndexForApprovers.vue b/resources/js/Pages/VacationRequest/IndexForApprovers.vue
index 9da88f4f..52e2b634 100644
--- a/resources/js/Pages/VacationRequest/IndexForApprovers.vue
+++ b/resources/js/Pages/VacationRequest/IndexForApprovers.vue
@@ -8,6 +8,8 @@ import { Inertia } from '@inertiajs/inertia'
 import { Listbox, ListboxButton, ListboxLabel, ListboxOption, ListboxOptions } from '@headlessui/vue'
 import Pagination from '@/Shared/Pagination.vue'
 import EmptyState from '@/Shared/Feedbacks/EmptyState.vue'
+import { DateTime } from 'luxon'
+import YearPicker from '@/Shared/Forms/YearPicker.vue'
 
 const props = defineProps({
   requests: Object,
@@ -16,6 +18,8 @@ const props = defineProps({
   types: Object,
 })
 
+const currentDate = DateTime.now()
+
 const statuses = [
   {
     name: 'Wszystkie',
@@ -43,6 +47,7 @@ const form = reactive({
   user: props.users.data.find(user => user.id === props.filters.user) ?? null,
   status: statuses.find(status => status.value === props.filters.status) ?? statuses[0],
   type: props.types.find(type => type.value === props.filters.type) ?? null,
+  year: props.filters.year ?? null,
 })
 
 watch(form, debounce(() => {
@@ -50,6 +55,7 @@ watch(form, debounce(() => {
     user: form.user?.id,
     status: form.status.value,
     type: form.type?.value,
+    year: form.year,
   }, {
     preserveState: true,
     replace: true,
@@ -76,7 +82,7 @@ watch(form, debounce(() => {
       </div>
     </div>
     <div class="border-t border-gray-200">
-      <div class="grid grid-cols-1 gap-2 p-4 md:grid-cols-3 md:gap-4">
+      <div class="grid grid-cols-1 gap-2 p-4 md:grid-cols-4 md:gap-4">
         <Listbox
           v-model="form.user"
           as="div"
@@ -294,6 +300,14 @@ watch(form, debounce(() => {
             </transition>
           </div>
         </Listbox>
+        <YearPicker
+          v-model="form.year"
+          nullable
+          label="Rok"
+          :from="currentDate.year + 1"
+          :to="currentDate.year - 20"
+          class="inline-block ml-2"
+        />
       </div>
     </div>
     <div class="overflow-auto xl:overflow-visible">
diff --git a/resources/js/Shared/CalendarComponent.vue b/resources/js/Shared/CalendarComponent.vue
index 1ce458d5..0a7a8889 100644
--- a/resources/js/Shared/CalendarComponent.vue
+++ b/resources/js/Shared/CalendarComponent.vue
@@ -1,11 +1,11 @@
 <script setup>
 import VacationPopup from '@/Shared/VacationPopup.vue'
 import useVacationTypeInfo from '@/Composables/vacationTypeInfo'
-import useCurrentYearPeriodInfo from '@/Composables/yearPeriodInfo'
 import { DateTime } from 'luxon'
 import Popper from 'vue3-popper'
 
 const props = defineProps({
+  year: Number,
   holidays: Object,
   vacations: Object,
   pendingVacations: Object,
@@ -15,12 +15,11 @@ const props = defineProps({
 
 
 const { findType } = useVacationTypeInfo()
-const { year } = useCurrentYearPeriodInfo()
 
 const months = []
 
 for (let i = props.startMonth; i < props.endMonth + 1; i++) {
-  const currentMonth = DateTime.fromObject({ year: year.value, month: i }).startOf('month')
+  const currentMonth = DateTime.fromObject({ year: props.year, month: i }).startOf('month')
 
   const start = currentMonth.startOf('week')
   const end = currentMonth.endOf('month').endOf('week')
diff --git a/resources/js/Shared/Forms/YearPicker.vue b/resources/js/Shared/Forms/YearPicker.vue
new file mode 100644
index 00000000..892ee766
--- /dev/null
+++ b/resources/js/Shared/Forms/YearPicker.vue
@@ -0,0 +1,113 @@
+<script setup>
+import { computed } from 'vue'
+import { Listbox, ListboxButton, ListboxLabel, ListboxOption, ListboxOptions } from '@headlessui/vue'
+import { range } from 'lodash'
+import { ChevronUpDownIcon, CheckIcon } from '@heroicons/vue/24/solid'
+import { DateTime } from 'luxon'
+
+const props = defineProps({
+  modelValue: [String, Number],
+  from: Number,
+  to: Number,
+  nullable: Boolean,
+  label: String,
+  resetButton: Boolean,
+})
+
+const currentDate = DateTime.now()
+
+const emit = defineEmits(['update:modelValue'])
+const value = computed({
+  get: () => props.modelValue,
+  set: (value) => {
+    emit('update:modelValue', value)
+  },
+})
+</script>
+
+<template>
+  <div>
+    <Listbox
+      v-model="value"
+      as="div"
+    >
+      <ListboxLabel
+        v-if="label"
+        class="block mb-2 text-sm font-medium text-gray-700"
+      >
+        {{ label }}
+      </ListboxLabel>
+      <div class="relative mt-1 sm:mt-0">
+        <ListboxButton
+          class="relative py-2 pr-10 pl-3 w-full text-left bg-white rounded-md border border-gray-300 focus:border-blumilk-500 focus:outline-none focus:ring-1 focus:ring-blumilk-500 shadow-sm cursor-default sm:text-sm"
+        >
+          <span class="flex items-center">
+            {{ value !== null || !nullable ? value : 'Wszystkie' }}
+          </span>
+          <span class="flex absolute inset-y-0 right-0 items-center pr-2 pointer-events-none">
+            <ChevronUpDownIcon class="w-5 h-5 text-gray-400" />
+          </span>
+        </ListboxButton>
+
+        <transition
+          leave-active-class="transition ease-in duration-100"
+          leave-from-class="opacity-100"
+          leave-to-class="opacity-0"
+        >
+          <ListboxOptions
+            class="overflow-auto absolute z-10 py-1 mt-1 max-h-60 text-base bg-white rounded-md focus:outline-none ring-1 ring-black ring-opacity-5 shadow-lg sm:text-sm"
+          >
+            <ListboxOption
+              v-if="nullable"
+              v-slot="{ active, selected }"
+              :value="null"
+              as="template"
+            >
+              <li
+                :class="[active ? 'bg-gray-100' : 'text-gray-900', 'cursor-default truncate select-none relative py-2 pl-3 pr-9']"
+              >
+                Wszystkie
+
+                <span
+                  v-if="selected"
+                  :class="['text-blumilk-600 absolute inset-y-0 right-0 flex items-center pr-4']"
+                >
+                  <CheckIcon class="w-5 h-5" />
+                </span>
+              </li>
+            </ListboxOption>
+            <ListboxOption
+              v-for="item in range(from, to + 1)"
+              :key="item"
+              v-slot="{ active, selected }"
+              :value="item"
+              as="template"
+            >
+              <li
+                :class="[active ? 'bg-gray-100' : 'text-gray-900', 'cursor-default truncate select-none relative py-2 pl-3 pr-9']"
+              >
+                {{ item }}
+
+                <span
+                  v-if="selected"
+                  :class="['text-blumilk-600 absolute inset-y-0 right-0 flex items-center pr-4']"
+                >
+                  <CheckIcon class="w-5 h-5" />
+                </span>
+              </li>
+            </ListboxOption>
+          </ListboxOptions>
+        </transition>
+      </div>
+    </Listbox>
+    <button
+      v-if="resetButton"
+      type="button"
+      class="font-semibold text-blumilk-600 hover:text-blumilk-500"
+      @click="value = currentDate.year"
+    >
+      Wróć do obecnego roku
+    </button>
+  </div>
+</template>
+
diff --git a/resources/js/Shared/Layout/AppLayout.vue b/resources/js/Shared/Layout/AppLayout.vue
index 20ff0abe..32d537e2 100644
--- a/resources/js/Shared/Layout/AppLayout.vue
+++ b/resources/js/Shared/Layout/AppLayout.vue
@@ -9,7 +9,6 @@ import { updateFavicon } from '@/Shared/updateFavicon'
 const props = defineProps({
   flash: Object,
   auth: Object,
-  years: Object,
   vacationRequestsCount: Number,
   overtimeRequestsCount: Number,
   deployInformation: Object,
@@ -53,7 +52,6 @@ function vacationPageOpened() {
       :show-refresh-button="isUpdated"
       :vacation-requests-count="vacationRequestsCount"
       :overtime-requests-count="overtimeRequestsCount"
-      :years="years"
       @open="vacationPageOpened"
     />
     <main class="flex flex-col flex-1 py-8 lg:ml-60">
diff --git a/resources/js/Shared/MainMenu.vue b/resources/js/Shared/MainMenu.vue
index 97489cb3..c2ddf4fc 100644
--- a/resources/js/Shared/MainMenu.vue
+++ b/resources/js/Shared/MainMenu.vue
@@ -33,11 +33,10 @@ import {
   XMarkIcon,
   ClockIcon,
 } from '@heroicons/vue/24/outline'
-import { CheckIcon, ChevronDownIcon } from '@heroicons/vue/24/solid'
+import { ChevronDownIcon } from '@heroicons/vue/24/solid'
 
 const props = defineProps({
   auth: Object,
-  years: Object,
   vacationRequestsCount: Number,
   overtimeRequestsCount: Number,
   showRefreshButton: Boolean,
@@ -405,89 +404,20 @@ const emit = defineEmits(['open'])
       >
         <Bars3CenterLeftIcon class="w-6 h-6" />
       </button>
-      <div class="flex flex-1 justify-between px-4 sm:px-6 lg:px-8">
-        <div class="flex items-center">
-          <div>
-            <Menu
-              as="div"
-              class="inline-block relative text-left"
-            >
-              <div class="flex justify-center items-center">
-                <div class="mr-4 text-sm">
-                  Wybrany rok:
-                </div>
-                <div>
-                  <MenuButton
-                    class="inline-flex justify-center py-2 px-4 w-full text-sm font-medium text-gray-700 bg-white hover:bg-gray-50 rounded-md border border-gray-300 focus:outline-none focus:ring-2 focus:ring-blumilk-500  shadow-sm"
-                  >
-                    {{ years.selected.year }}
-                    <ChevronDownIcon class="-mr-1 ml-2 w-5 h-5" />
-                  </MenuButton>
-                </div>
-                <button
-                  v-if="showRefreshButton && refreshablePages.includes($page.component)"
-                  class="inline-flex items-center py-2.5 px-4 text-sm font-medium leading-4 text-white bg-blumilk-600 hover:bg-blumilk-700 rounded-md border border-transparent focus:outline-none focus:ring-2 focus:ring-blumilk-500 focus:ring-offset-2 shadow-sm ml-3"
-                  @click="reloadPage"
-                >
-                  <div class="hidden sm:block">
-                    Odśwież
-                  </div>
-                  <div class="sm:hidden">
-                    <ArrowPathIcon class="h-4 w-4" />
-                  </div>
-                </button>
-              </div>
-
-              <transition
-                enter-active-class="transition ease-out duration-100"
-                enter-from-class="transform opacity-0 scale-95"
-                enter-to-class="transform opacity-100 scale-100"
-                leave-active-class="transition ease-in duration-75"
-                leave-from-class="transform opacity-100 scale-100"
-                leave-to-class="transform opacity-0 scale-95"
-              >
-                <MenuItems
-                  class="absolute right-0 mt-2 w-24 bg-white rounded-md focus:outline-none ring-1 ring-black ring-opacity-5 shadow-lg origin-top-right"
-                >
-                  <div class="py-1">
-                    <MenuItem
-                      v-for="(item, index) in years.navigation"
-                      :key="index"
-                      v-slot="{ active }"
-                    >
-                      <InertiaLink
-                        :class="[active ? 'bg-gray-100 text-gray-900' : 'text-gray-700', 'flex w-full px-4 py-2 text-sm']"
-                        :href="item.link"
-                        :preserve-state="false"
-                        as="button"
-                        method="post"
-                      >
-                        {{ item.year }}
-                        <CheckIcon
-                          v-if="item.year === years.selected.year"
-                          class="ml-2 w-5 h-5 text-blumilk-500"
-                        />
-                      </InertiaLink>
-                    </MenuItem>
-                  </div>
-                </MenuItems>
-              </transition>
-            </Menu>
-          </div>
-          <div
-            v-if="years.current.year !== years.selected.year"
-            class="hidden ml-3 text-sm sm:block"
+      <div class="flex flex-1 justify-between items-center px-4 sm:px-6 lg:px-8">
+        <div>
+          <button
+            v-if="showRefreshButton && refreshablePages.includes($page.component)"
+            class="inline-flex items-center py-2.5 px-4 text-sm font-medium leading-4 text-white bg-blumilk-600 hover:bg-blumilk-700 rounded-md border border-transparent focus:outline-none focus:ring-2 focus:ring-blumilk-500 focus:ring-offset-2 shadow-sm ml-3"
+            @click="reloadPage"
           >
-            <InertiaLink
-              :href="years.current.link"
-              :preserve-state="false"
-              as="button"
-              class="font-semibold text-blumilk-600 hover:text-blumilk-500"
-              method="post"
-            >
-              Wróć do obecnego roku
-            </inertialink>
-          </div>
+            <div class="hidden sm:block">
+              Odśwież
+            </div>
+            <div class="sm:hidden">
+              <ArrowPathIcon class="h-4 w-4" />
+            </div>
+          </button>
         </div>
         <div class="flex items-center ml-4 md:ml-6">
           <Menu
diff --git a/resources/js/Shared/Modals/TakeVacationDaysFromPreviousYearModal.vue b/resources/js/Shared/Modals/TakeVacationDaysFromPreviousYearModal.vue
index 377e02bb..65291bfb 100644
--- a/resources/js/Shared/Modals/TakeVacationDaysFromPreviousYearModal.vue
+++ b/resources/js/Shared/Modals/TakeVacationDaysFromPreviousYearModal.vue
@@ -17,6 +17,8 @@ const emit = defineEmits(['close', 'changed'])
 const allDays = ref(0)
 
 const form = useForm({
+  user: props.limit?.user.id,
+  year: props.year,
   days: 0,
 })
 
@@ -28,11 +30,7 @@ function cancel() {
 
 function submitForm() {
   form
-    .transform(data => ({
-      ...data,
-      city: data.city?.id,
-    }))
-    .post(`/vacation/limits/${props.limit.id}/take-from-last-year`, {
+    .post('/vacation/limits/take-from-last-year', {
       preserveState: (page) => Object.keys(page.props.errors).length,
       preserveScroll: true,
       onSuccess() {
@@ -47,7 +45,9 @@ watch(() => props.show, () => {
   }
 
   allDays.value = props.limit.remainingLastYear + props.limit.fromPreviousYear
-  form.defaults('days', props.limit.fromPreviousYear)
+  form.defaults('days', props.limit?.fromPreviousYear)
+  form.defaults('year', props.year)
+  form.defaults('user', props.limit?.user.id)
   form.reset()
   form.clearErrors()
 })
@@ -123,7 +123,7 @@ watch(() => props.show, () => {
                     for="name"
                     class="block text-sm font-medium text-gray-700 mb-2"
                   >
-                    Przeniesione dni na rok {{ year + 1 }}
+                    Przeniesione dni na rok {{ year }}
                   </label>
                   <input
                     v-model="form.days"
@@ -144,7 +144,7 @@ watch(() => props.show, () => {
                     for="name"
                     class="block text-sm font-medium text-gray-700 mb-2"
                   >
-                    Pozostałe dni w roku {{ year }}
+                    Pozostałe dni w roku {{ year - 1 }}
                   </label>
                   <div class="inline-flex items-center py-2 px-4 mt-1 w-full max-w-lg text-gray-500 bg-gray-50 rounded-md border border-gray-300 sm:col-span-2 sm:mt-0 sm:text-sm">
                     {{ remaining }}
diff --git a/resources/js/Shared/RemainingFromPreviousYearPopup.vue b/resources/js/Shared/RemainingFromPreviousYearPopup.vue
index 2fe6f8e5..e2f11725 100644
--- a/resources/js/Shared/RemainingFromPreviousYearPopup.vue
+++ b/resources/js/Shared/RemainingFromPreviousYearPopup.vue
@@ -30,7 +30,7 @@ defineProps({
           </div>
           <div class="py-2 space-y-1">
             <dt class="text-sm font-medium text-gray-500">
-              Przeniesione na {{ year + 1 }}
+              Przeniesione na {{ year }}
             </dt>
             <dd class="mt-1 text-sm text-gray-900">
               {{ toNextYear ?? 0 }}
diff --git a/resources/js/Shared/Widgets/VacationCalendar.vue b/resources/js/Shared/Widgets/VacationCalendar.vue
index 71a016fb..63e326b4 100644
--- a/resources/js/Shared/Widgets/VacationCalendar.vue
+++ b/resources/js/Shared/Widgets/VacationCalendar.vue
@@ -1,10 +1,9 @@
 <script setup>
 import { CheckIcon, ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon } from '@heroicons/vue/24/solid'
 import { Menu, MenuButton, MenuItem, MenuItems } from '@headlessui/vue'
-import { ref, watch, computed, reactive } from 'vue'
+import { computed, reactive, onMounted } from 'vue'
 import { DateTime } from 'luxon'
 import useVacationTypeInfo from '@/Composables/vacationTypeInfo.js'
-import useCurrentYearPeriodInfo from '@/Composables/yearPeriodInfo.js'
 import { useMonthInfo } from '@/Composables/monthInfo.js'
 import { viewModes, find as findViewMode } from '@/Shared/Widgets/Calendar/ViewModeOptions.js'
 import DayComponent from '@/Shared/Widgets/Calendar/DayComponent.vue'
@@ -15,194 +14,90 @@ const props = defineProps({
   pendingVacations: Object,
 })
 
-let days = ref([])
-
-function getCurrentDate() {
-  const { year, month, weekNumber } = DateTime.now()
-  return { year, month, week: weekNumber }
-}
-const currentDate = getCurrentDate()
-
+const currentDate = DateTime.now()
 const months = useMonthInfo().getMonths()
 const { findType } = useVacationTypeInfo()
-const selectedYear = useCurrentYearPeriodInfo().year.value
-const weeksInYear = DateTime.fromObject({ year: selectedYear, month: 12, day: 31 }).weekNumber
-
-const calendar = {
-  viewMode: ref(localStorage.getItem('calendarViewMode') ?? 'week'),
-  currents: reactive({
-    year: selectedYear,
-    month: selectedYear === currentDate.year ? currentDate.month : 1,
-    week: selectedYear === currentDate.year ? currentDate.week : 0,
-  }),
-}
+
+const viewMode = localStorage.getItem('calendarViewMode') ?? 'week'
+
+const calendar = reactive({
+  days: [],
+  viewMode: viewMode,
+  date: currentDate.startOf('week'),
+})
 
 const calendarState = reactive({
   viewMode: {
-    isWeek: computed(() => calendar.viewMode.value === 'week'),
-    isMonth: computed(() => calendar.viewMode.value === 'month'),
-    details: computed(() => findViewMode(calendar.viewMode.value)),
+    isWeek: computed(() => calendar.viewMode === 'week'),
+    isMonth: computed(() => calendar.viewMode === 'month'),
+    details: computed(() => findViewMode(calendar.viewMode)),
   },
-  monthName: computed(() => months[calendar.currents.month - 1]?.name),
-  isActualYear: computed(() => calendar.currents.year === DateTime.now().year),
-  isPrevious: computed(() => calendarState.viewMode.isMonth ? calendar.currents.month !== 1 : calendar.currents.week > 0),
-  isNext: computed(() => calendarState.viewMode.isMonth ? calendar.currents.month !== 12 : calendar.currents.week < weeksInYear),
+  monthName: computed(() => months[calendar.date.month - 1]?.name),
+  isPrevious: computed(() => calendar.date.minus({ [calendar.viewMode]: 1 }).year === currentDate.year),
+  isNext: computed(() => calendar.date.plus({ [calendar.viewMode]: 1 }).year === currentDate.year),
 })
 
-const customCalendar = {
-  loadCalendar() {
-    const date = DateTime.fromObject({
-      year: calendar.currents.year,
-      month: calendarState.viewMode.isMonth ? calendar.currents.month : 1,
-      day: 1,
-    })
-    days.value = this.generateCalendarData(date)
-  },
-  generateCalendarData(date) {
-    const firstMonthDay = date.startOf('month')
-    const lastMonthDay = date.endOf('month')
-
-    if (calendarState.viewMode.isWeek) {
-      return this.generateWeekData(firstMonthDay.startOf('week'))
-    } else if (calendarState.viewMode.isMonth) {
-      return this.generateMonthData(firstMonthDay.startOf('week'), lastMonthDay.endOf('week'))
-    }
-    return []
-  },
-  generateWeekData(start) {
-    let days = [], startWeek
-    if (calendar.currents.month === 1 && calendar.currents.week === 0)
-      startWeek = DateTime.fromObject({ year: calendar.currents.year, month: 1, day: 1 }).startOf('week')
-    else if (calendarState.isActualYear)
-      startWeek = DateTime.fromObject({ weekNumber: calendar.currents.week })
-    else
-      startWeek = start.plus({ week: calendar.currents.week })
-    const endWeek = startWeek.endOf('week')
-    for (let day = startWeek; day < endWeek; day = day.plus({ day: 1 })) {
-      days.push(this.prepareDay(day))
-    }
-    return days
-  },
-  generateMonthData(start, end) {
-    let days = []
-    for (let day = start; day < end; day = day.plus({ day: 1 })) {
-      days.push(this.prepareDay(day))
-    }
+onMounted(() => loadCalendar())
 
-    return days
-  },
-  prepareDay(day) {
-    const isCurrentMonth = isInCurrentMonth(day)
-    const startDay = {
-      date: day.toISODate(),
-      isVacation: isCurrentMonth && isVacation(day),
-      isPendingVacation: isCurrentMonth && isPendingVacation(day),
-      isHoliday: isHoliday(day),
-    }
-
-    return {
-      ...startDay,
-      dayNumber: day.day,
-      isCurrentMonth,
-      isToday: isToday(day),
-      isWeekend: isWeekend(day),
-      getHolidayInfo: startDay.isHoliday ? getHolidayInfo(startDay) : undefined,
-      getVacationType: startDay.isVacation || startDay.isPendingVacation ? getVacationType(startDay) : undefined,
-      getVacationInfo: startDay.isVacation || startDay.isPendingVacation ? getVacationInfo(startDay) : undefined,
-    }
-  },
-}
+function loadCalendar() {
+  let days = []
 
-watch([calendar.viewMode, calendar.currents], () => {
-  customCalendar.loadCalendar()
-})
-
-customCalendar.loadCalendar()
+  const start = calendar.date.startOf(calendar.viewMode).startOf('week')
+  const end = calendar.date.endOf(calendar.viewMode).endOf('week')
 
-function toPrevious() {
-  if (calendarState.isPrevious) {
-    if (calendar.viewMode.value === 'week')
-      minusWeek()
-    else
-      minusMonth()
+  for (let day = start; day < end; day = day.plus({ day: 1 })) {
+    days.push(prepareDay(day))
   }
-}
 
-function toNext() {
-  if (calendarState.isNext) {
-    if (calendar.viewMode.value === 'week')
-      addWeek()
-    else
-      addMonth()
-  }
+  calendar.days = days
 }
+function prepareDay(day) {
+  const isCurrentMonth = isInCurrentMonth(day)
+  const startDay = {
+    date: day.toISODate(),
+    isVacation: isCurrentMonth && isVacation(day),
+    isPendingVacation: isCurrentMonth && isPendingVacation(day),
+    isHoliday: isHoliday(day),
+  }
 
-function resetCalendar(config = {}) {
-  const currentMonth = isUndefined(config.month) ? currentDate.month : config.month
-  const currentWeek = isUndefined(config.week) ? currentDate.week : config.week
-
-  calendar.currents.year = isUndefined(config.year) ? selectedYear : config.month
-  calendar.currents.month = calendarState.isActualYear || !isUndefined(config.year) ? currentMonth : 1
-  calendar.currents.week = calendarState.isActualYear || !isUndefined(config.week) ? currentWeek : 0
+  return {
+    ...startDay,
+    dayNumber: day.day,
+    isCurrentMonth,
+    isToday: isToday(day),
+    isWeekend: isWeekend(day),
+    getHolidayInfo: startDay.isHoliday ? getHolidayInfo(startDay) : undefined,
+    getVacationType: startDay.isVacation || startDay.isPendingVacation ? getVacationType(startDay) : undefined,
+    getVacationInfo: startDay.isVacation || startDay.isPendingVacation ? getVacationInfo(startDay) : undefined,
+  }
 }
 
-function isUndefined(value) {
-  return value === undefined
-}
+function today() {
+  calendar.date = currentDate
 
-function addWeek(minus = false) {
-  const howMany = minus ? -1: 1
-  let nextMonth, date = DateTime.fromObject({
-    year: calendar.currents.year,
-    month: 1,
-    day: 1,
-  })
-
-  date = date.plus({ week: calendar.currents.week + howMany })
-
-  const startWeekDay = date.startOf('week'), endWeekDay = date.endOf('week')
-  nextMonth = howMany > 0 ? startWeekDay.month : endWeekDay.month
-  if (howMany < 0 && endWeekDay.day === endWeekDay.daysInMonth)
-    calendar.currents.week--
-  else if (howMany > 0 && startWeekDay.day === 1)
-    calendar.currents.week++
-
-  if (nextMonth !== calendar.currents.month) {
-    calendar.currents.month = calendar.currents.week > 1 ? nextMonth : 1
-    if (calendar.currents.week === 1)
-      calendar.currents.week = 0
-    return
-  }
-  calendar.currents.week += howMany
+  loadCalendar()
 }
 
-function minusWeek() {
-  addWeek(true)
-}
+function previous() {
+  calendar.date = calendar.date.minus({ [calendar.viewMode]: 1 })
 
-function addMonth(minus = false) {
-  calendar.currents.month += minus ? -1 : 1
+  loadCalendar()
 }
 
-function minusMonth() {
-  addMonth(true)
-}
+function next() {
+  calendar.date = calendar.date.plus({ [calendar.viewMode]: 1 })
 
-function goToToday() {
-  resetCalendar({ year: currentDate.year, months: currentDate.month, week: currentDate.week })
+  loadCalendar()
 }
 
 function updateViewMode(type) {
-  if (type === 'month')
-    resetCalendar({ week: 0 })
-  else
-    resetCalendar()
-  calendar.viewMode.value = type
+  calendar.viewMode = type
   localStorage.setItem('calendarViewMode', type)
+  loadCalendar()
 }
 
 function isInCurrentMonth(date) {
-  return calendar.currents.month === date.month
+  return calendar.date.month === date.month
 }
 
 function isWeekend(date) {
@@ -242,7 +137,7 @@ function getVacationInfo(day) {
   <section class="bg-white shadow-md">
     <div class="grid grid-cols-3 grid-rows-1 items-center justify-center p-4 sm:px-6">
       <h2 class="text-lg font-medium leading-6 text-gray-900">
-        {{ calendarState.monthName }} {{ !calendarState.isActualYear ? calendar.currents.year : undefined }}
+        {{ calendarState.monthName }} {{ calendar.date.year }}
       </h2>
       <div class="flex justify-center">
         <div class="flex items-center rounded-md shadow-sm md:items-stretch">
@@ -250,7 +145,8 @@ function getVacationInfo(day) {
             type="button"
             class="flex items-center justify-center rounded-l-md border border-r-0 border-gray-300 py-2 pl-3 pr-4 text-gray-400 focus:relative md:w-9 md:px-2"
             :class="[ calendarState.isPrevious ? 'bg-white hover:text-gray-500 md:hover:bg-gray-50' : 'bg-gray-100' ]"
-            @click="toPrevious"
+            :disabled="!calendarState.isPrevious"
+            @click="previous"
           >
             <span class="sr-only">Poprzedni {{ calendarState.viewMode.details.shortcut }}</span>
             <ChevronLeftIcon
@@ -261,7 +157,7 @@ function getVacationInfo(day) {
           <button
             type="button"
             class="hidden border-t border-b border-gray-300 bg-white px-3.5 text-sm font-medium text-gray-700 hover:bg-gray-50 hover:text-gray-900 focus:relative md:block"
-            @click="goToToday"
+            @click="today"
           >
             Dzisiaj
           </button>
@@ -273,7 +169,7 @@ function getVacationInfo(day) {
             class="flex items-center justify-center rounded-r-md border border-l-0 border-gray-300 py-2 pl-4 pr-3 text-gray-400 focus:relative md:w-9 md:px-2"
             :class="[ calendarState.isNext ? 'bg-white hover:text-gray-500 md:hover:bg-gray-50' : 'bg-gray-100' ]"
             :disabled="!calendarState.isNext"
-            @click="toNext"
+            @click="next"
           >
             <span class="sr-only">Następny {{ calendarState.viewMode.details.shortcut }}</span>
             <ChevronRightIcon
@@ -308,7 +204,9 @@ function getVacationInfo(day) {
           leave-from-class="transform opacity-100 scale-100"
           leave-to-class="transform opacity-0 scale-95"
         >
-          <MenuItems class="absolute right-0 mt-3 w-36 origin-top-right overflow-hidden rounded-md bg-white shadow-lg ring-1 ring-black ring-opacity-5 focus:outline-none">
+          <MenuItems
+            class="absolute right-0 mt-3 w-36 origin-top-right overflow-hidden rounded-md bg-white shadow-lg ring-1 ring-black ring-opacity-5 focus:outline-none"
+          >
             <div class="py-1">
               <MenuItem
                 v-for="option in viewModes"
@@ -364,7 +262,7 @@ function getVacationInfo(day) {
           :class="{ 'grid-rows-1': calendarState.viewMode.isWeek }"
         >
           <DayComponent
-            v-for="(day, index) in days"
+            v-for="(day, index) in calendar.days"
             :key="index"
             :day="day"
             class="flex flex-col relative p-3"
diff --git a/resources/views/pdf/vacation-request.blade.php b/resources/views/pdf/vacation-request.blade.php
index 0df1bab5..8b8e3ea1 100644
--- a/resources/views/pdf/vacation-request.blade.php
+++ b/resources/views/pdf/vacation-request.blade.php
@@ -74,7 +74,7 @@
         <h2>Wniosek</h2>
         <p class="content">
             Proszę o {{ mb_strtolower($vacationRequest->type->label()) }} w okresie od dnia {{ $vacationRequest->from->format("d.m.Y") }}
-            do dnia {{ $vacationRequest->to->format("d.m.Y") }} włącznie tj. {{ $vacationRequest->vacations()->count() }} dni roboczych za rok {{ $vacationRequest->yearPeriod->year }}.
+            do dnia {{ $vacationRequest->to->format("d.m.Y") }} włącznie tj. {{ $vacationRequest->vacations()->count() }} dni roboczych za rok {{ $vacationRequest->to->year }}.
         </p>
     </div>
 
diff --git a/routes/console.php b/routes/console.php
index ccfa9a82..664c9161 100644
--- a/routes/console.php
+++ b/routes/console.php
@@ -5,6 +5,7 @@
 use Illuminate\Cache\Console\PruneStaleTagsCommand;
 use Illuminate\Support\Facades\Schedule;
 use Toby\Console\Commands\Database\BackupPostgresDatabase;
+use Toby\Console\Commands\GenerateHolidays;
 use Toby\Console\Commands\SendDailySummaryToSlack;
 use Toby\Console\Commands\SendNotificationAboutBenefitsReportCreation;
 use Toby\Console\Commands\SendNotificationAboutUpcomingAndOverdueMedicalExams;
@@ -13,7 +14,6 @@
 use Toby\Console\Commands\SendNotificationAboutUpcomingOhsTrainingsForEmployees;
 use Toby\Console\Commands\SendOvertimeRequestSummariesToApprovers;
 use Toby\Console\Commands\SendVacationRequestSummariesToApprovers;
-use Toby\Jobs\CheckYearPeriod;
 
 Schedule::command(SendDailySummaryToSlack::class)
     ->when(config("services.slack.enabled"))
@@ -43,7 +43,7 @@
     ->lastDayOfMonth("08:00")
     ->onOneServer();
 
-Schedule::job(CheckYearPeriod::class)
+Schedule::command(GenerateHolidays::class)
     ->yearlyOn(1, 1, "01:00")
     ->onOneServer();
 
diff --git a/routes/web.php b/routes/web.php
index 26f21ff2..38ad0bd4 100644
--- a/routes/web.php
+++ b/routes/web.php
@@ -22,7 +22,6 @@
 use Toby\Http\Controllers\OvertimeTimesheetController;
 use Toby\Http\Controllers\PermissionController;
 use Toby\Http\Controllers\ResumeController;
-use Toby\Http\Controllers\SelectYearPeriodController;
 use Toby\Http\Controllers\TechnologyController;
 use Toby\Http\Controllers\TimesheetController;
 use Toby\Http\Controllers\UserController;
@@ -125,17 +124,13 @@
     Route::get("/employees-milestones", [EmployeesMilestonesController::class, "index"])
         ->name("employees-milestones");
 
-    Route::post("/year-periods/{yearPeriod}/select", SelectYearPeriodController::class)
-        ->whereNumber("yearPeriod")
-        ->name("year-periods.select");
-
     Route::get("/calendar/{month?}/{year?}", [VacationCalendarController::class, "index"])
         ->name("calendar");
 
     Route::prefix("/vacation")->as("vacation.")->group(function (): void {
         Route::get("/limits", [VacationLimitController::class, "edit"])
             ->name("limits");
-        Route::post("/limits/{limit}/take-from-last-year", [VacationLimitController::class, "takeFromLastYear"])
+        Route::post("/limits/take-from-last-year", [VacationLimitController::class, "takeFromLastYear"])
             ->name("limits.take");
 
         Route::get("/timesheet/{month}", TimesheetController::class)
diff --git a/tests/Feature/CalendarTest.php b/tests/Feature/CalendarTest.php
index 3fcc812b..43f917c3 100644
--- a/tests/Feature/CalendarTest.php
+++ b/tests/Feature/CalendarTest.php
@@ -7,7 +7,6 @@
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 use Tests\FeatureTestCase;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 class CalendarTest extends FeatureTestCase
 {
@@ -22,41 +21,17 @@ protected function setUp(): void
         $this->user = User::factory()->create();
     }
 
-    public function testUserCanChangeYearPeriodOnTheCalendar(): void
+    public function testUserCanSeeCalendarWithDefaultMonthAndYear(): void
     {
-        $currentYearPeriod = YearPeriod::current();
-        $nextYearPeriod = YearPeriod::query()
-            ->create([
-                "year" => $currentYearPeriod->year + 1,
-            ]);
-
-        $this->assertNotEquals($currentYearPeriod->year, $nextYearPeriod->year);
-
         $this->actingAs($this->user)
-            ->get("/calendar/january/$nextYearPeriod->year")
-            ->assertRedirect();
-
-        $selectedYearPeriod = YearPeriod::query()->where("id", session()->get("selected_year_period"))->first();
-        $this->assertEquals($selectedYearPeriod->year, $nextYearPeriod->year);
-    }
-
-    public function testUserCannotChangeYearPeriodIfYearPeriodDoesNotExist(): void
-    {
-        $currentYearPeriod = YearPeriod::current();
-
-        $this->actingAs($this->user)
-            ->get("/calendar/january/" . ($currentYearPeriod->year + 1))
-            ->assertStatus(404);
-
-        $this->actingAs($this->user)
-            ->get("/calendar/january/$currentYearPeriod->year")
-            ->assertStatus(302);
+            ->get("/calendar")
+            ->assertOk();
     }
 
-    public function testUserCanSeeCalendar(): void
+    public function testUserCanSeeCalendarWithSelectedMonthAndYear(): void
     {
         $this->actingAs($this->user)
-            ->get("/calendar")
+            ->get("/calendar/05-2024")
             ->assertOk();
     }
 }
diff --git a/tests/Feature/HolidayTest.php b/tests/Feature/HolidayTest.php
index 9cf88a2d..24ccb315 100644
--- a/tests/Feature/HolidayTest.php
+++ b/tests/Feature/HolidayTest.php
@@ -10,7 +10,6 @@
 use Tests\FeatureTestCase;
 use Toby\Models\Holiday;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 
 class HolidayTest extends FeatureTestCase
 {
@@ -18,10 +17,13 @@ class HolidayTest extends FeatureTestCase
 
     public function testUserCanSeeHolidayList(): void
     {
-        Holiday::factory()->count(10)->create();
+        Holiday::factory()
+            ->count(1)
+            ->create(["date" => Carbon::now()]);
+
         $user = User::factory()->create();
 
-        $this->assertDatabaseCount("holidays", 10);
+        $this->assertDatabaseCount("holidays", 1);
 
         $this->actingAs($user)
             ->get("/holidays")
@@ -29,7 +31,7 @@ public function testUserCanSeeHolidayList(): void
             ->assertInertia(
                 fn(Assert $page) => $page
                     ->component("Holidays/Index")
-                    ->has("holidays.data", 10),
+                    ->has("holidays.data", 1),
             );
     }
 
@@ -37,42 +39,27 @@ public function testAdminCanCreateHoliday(): void
     {
         $admin = User::factory()->admin()->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = Carbon::now()->year;
 
         $this->actingAs($admin)
             ->post("/holidays", [
                 "name" => "Holiday 1",
-                "date" => Carbon::create($currentYearPeriod->year, 5, 20)->toDateString(),
+                "date" => Carbon::create($year, 5, 20)->toDateString(),
             ])
             ->assertSessionHasNoErrors();
 
         $this->assertDatabaseHas("holidays", [
             "name" => "Holiday 1",
-            "date" => Carbon::create($currentYearPeriod->year, 5, 20),
-            "year_period_id" => YearPeriod::current()->id,
+            "date" => Carbon::create($year, 5, 20),
         ]);
     }
 
-    public function testAdminCannotCreateHolidayForYearPeriodThatDoesntExist(): void
-    {
-        $admin = User::factory()->admin()->create();
-
-        $year = YearPeriod::query()->max("year") + 1;
-
-        $this->actingAs($admin)
-            ->post("/holidays", [
-                "name" => "Holiday 1",
-                "date" => Carbon::create($year, 5, 20)->toDateString(),
-            ])
-            ->assertSessionHasErrors(["date"]);
-    }
-
     public function testAdminCannotCreateHolidayIfGivenDataIsUsed(): void
     {
         $admin = User::factory()->admin()->create();
 
-        $currentYearPeriod = YearPeriod::current();
-        $sameDate = Carbon::create($currentYearPeriod->year, 5, 20)->toDateString();
+        $year = Carbon::now()->year;
+        $sameDate = Carbon::create($year, 5, 20)->toDateString();
 
         Holiday::factory()->create([
             "name" => "Holiday",
@@ -91,30 +78,28 @@ public function testAdminCanEditHoliday(): void
     {
         $admin = User::factory()->admin()->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = Carbon::now()->year;
 
         $holiday = Holiday::factory()->create([
             "name" => "Name to change",
-            "date" => Carbon::create($currentYearPeriod->year, 5, 20),
+            "date" => Carbon::create($year, 5, 20),
         ]);
 
         $this->assertDatabaseHas("holidays", [
             "name" => $holiday->name,
             "date" => $holiday->date->toDateString(),
-            "year_period_id" => $currentYearPeriod->id,
         ]);
 
         $this->actingAs($admin)
             ->put("/holidays/{$holiday->id}", [
                 "name" => "Holiday 1",
-                "date" => Carbon::create($currentYearPeriod->year, 10, 25)->toDateString(),
+                "date" => Carbon::create($year, 10, 25)->toDateString(),
             ])
             ->assertSessionHasNoErrors();
 
         $this->assertDatabaseHas("holidays", [
             "name" => "Holiday 1",
-            "date" => Carbon::create($currentYearPeriod->year, 10, 25)->toDateString(),
-            "year_period_id" => $currentYearPeriod->id,
+            "date" => Carbon::create($year, 10, 25)->toDateString(),
         ]);
     }
 
diff --git a/tests/Feature/OvertimeRequestTest.php b/tests/Feature/OvertimeRequestTest.php
index 7b348e10..b6a052ac 100644
--- a/tests/Feature/OvertimeRequestTest.php
+++ b/tests/Feature/OvertimeRequestTest.php
@@ -13,7 +13,6 @@
 use Toby\Models\OvertimeRequest;
 use Toby\Models\Profile;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 use Toby\States\OvertimeRequest\Approved;
 use Toby\States\OvertimeRequest\Cancelled;
 use Toby\States\OvertimeRequest\Rejected;
@@ -30,13 +29,13 @@ public function testUserCanSeeOvertimeRequestsList(): void
             ->employee()
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $year = Carbon::now();
 
         OvertimeRequest::factory()
             ->count(10)
             ->for($user)
-            ->for($currentYearPeriod)
-            ->create();
+            ->create(["from" => $year]);
 
         $this->actingAs($user)
             ->get("/overtime/requests/me")
@@ -55,14 +54,14 @@ public function testUserWithEmploymentContractCanCreateOvertimeRequest(): void
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = Carbon::now()->year;
 
         $this->actingAs($user)
             ->post("/overtime/requests", [
                 "user" => $user->id,
                 "type" => SettlementType::Money->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7, 20)->format("Y-m-d H:i"),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 7, 23)->format("Y-m-d H:i"),
+                "from" => Carbon::create($year, 2, 7, 20)->format("Y-m-d H:i"),
+                "to" => Carbon::create($year, 2, 7, 23)->format("Y-m-d H:i"),
                 "comment" => "Comment for the overtime request.",
             ])
             ->assertSessionHasNoErrors()
@@ -70,11 +69,10 @@ public function testUserWithEmploymentContractCanCreateOvertimeRequest(): void
 
         $this->assertDatabaseHas("overtime_requests", [
             "user_id" => $user->id,
-            "year_period_id" => $currentYearPeriod->id,
             "settlement_type" => SettlementType::Money->value,
             "state" => WaitingForTechnical::$name,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 7, 20)->format("Y-m-d H:i"),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 7, 23)->format("Y-m-d H:i"),
+            "from" => Carbon::create($year, 2, 7, 20)->format("Y-m-d H:i"),
+            "to" => Carbon::create($year, 2, 7, 23)->format("Y-m-d H:i"),
             "hours" => 3,
             "comment" => "Comment for the overtime request.",
         ]);
@@ -207,23 +205,23 @@ public function testEmployeeCannotCreateOvertimeRequestIfHeHasPendingOvertimeReq
         $user = User::factory()
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $year = Carbon::now()->year;
 
         OvertimeRequest::factory([
             "state" => WaitingForTechnical::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 7, 19)->format("Y-m-d H:i"),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 7, 22)->format("Y-m-d H:i"),
+            "from" => Carbon::create($year, 2, 7, 19)->format("Y-m-d H:i"),
+            "to" => Carbon::create($year, 2, 7, 22)->format("Y-m-d H:i"),
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
             ->post("/overtime/requests", [
                 "user" => $user->id,
                 "type" => SettlementType::Money->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7, 21)->format("Y-m-d H:i"),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 7, 23)->format("Y-m-d H:i"),
+                "from" => Carbon::create($year, 2, 7, 21)->format("Y-m-d H:i"),
+                "to" => Carbon::create($year, 2, 7, 23)->format("Y-m-d H:i"),
             ])
             ->assertSessionHasErrors([
                 "overtimeRequest" => __("You have a pending request in this date range."),
@@ -233,8 +231,8 @@ public function testEmployeeCannotCreateOvertimeRequestIfHeHasPendingOvertimeReq
             ->post("/overtime/requests", [
                 "user" => $user->id,
                 "type" => SettlementType::Money->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7, 18)->format("Y-m-d H:i"),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 7, 22)->format("Y-m-d H:i"),
+                "from" => Carbon::create($year, 2, 7, 18)->format("Y-m-d H:i"),
+                "to" => Carbon::create($year, 2, 7, 22)->format("Y-m-d H:i"),
             ])
             ->assertSessionHasErrors([
                 "overtimeRequest" => __("You have a pending request in this date range."),
@@ -244,8 +242,8 @@ public function testEmployeeCannotCreateOvertimeRequestIfHeHasPendingOvertimeReq
             ->post("/overtime/requests", [
                 "user" => $user->id,
                 "type" => SettlementType::Money->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7, 21)->format("Y-m-d H:i"),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 7, 22)->format("Y-m-d H:i"),
+                "from" => Carbon::create($year, 2, 7, 21)->format("Y-m-d H:i"),
+                "to" => Carbon::create($year, 2, 7, 22)->format("Y-m-d H:i"),
             ])
             ->assertSessionHasErrors([
                 "overtimeRequest" => __("You have a pending request in this date range."),
@@ -255,8 +253,8 @@ public function testEmployeeCannotCreateOvertimeRequestIfHeHasPendingOvertimeReq
             ->post("/overtime/requests", [
                 "user" => $user->id,
                 "type" => SettlementType::Money->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 6, 21)->format("Y-m-d H:i"),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 8, 22)->format("Y-m-d H:i"),
+                "from" => Carbon::create($year, 2, 6, 21)->format("Y-m-d H:i"),
+                "to" => Carbon::create($year, 2, 8, 22)->format("Y-m-d H:i"),
             ])
             ->assertSessionHasErrors([
                 "overtimeRequest" => __("You have a pending request in this date range."),
@@ -268,23 +266,23 @@ public function testEmployeeCannotCreateOvertimeRequestIfHeHasSettledOvertimeReq
         $user = User::factory()
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $year = Carbon::now()->year;
 
         OvertimeRequest::factory([
             "state" => Settled::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 7, 20)->format("Y-m-d H:i"),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 7, 22)->format("Y-m-d H:i"),
+            "from" => Carbon::create($year, 2, 7, 20)->format("Y-m-d H:i"),
+            "to" => Carbon::create($year, 2, 7, 22)->format("Y-m-d H:i"),
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
             ->post("/overtime/requests", [
                 "user" => $user->id,
                 "type" => SettlementType::Money->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7, 21)->format("Y-m-d H:i"),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 7, 23)->format("Y-m-d H:i"),
+                "from" => Carbon::create($year, 2, 7, 21)->format("Y-m-d H:i"),
+                "to" => Carbon::create($year, 2, 7, 23)->format("Y-m-d H:i"),
             ])
             ->assertSessionHasErrors([
                 "overtimeRequest" => __("You have a pending request in this date range."),
@@ -420,14 +418,14 @@ public function testOvertimeRequestHoursAreRoundedUp(): void
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = Carbon::now()->year;
 
         $this->actingAs($user)
             ->post("/overtime/requests", [
                 "user" => $user->id,
                 "type" => SettlementType::Money->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7, 20)->format("Y-m-d H:i"),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 7, 23, 5)->format("Y-m-d H:i"),
+                "from" => Carbon::create($year, 2, 7, 20)->format("Y-m-d H:i"),
+                "to" => Carbon::create($year, 2, 7, 23, 5)->format("Y-m-d H:i"),
                 "comment" => "Comment for the overtime request.",
             ])
             ->assertSessionHasNoErrors()
@@ -435,11 +433,10 @@ public function testOvertimeRequestHoursAreRoundedUp(): void
 
         $this->assertDatabaseHas("overtime_requests", [
             "user_id" => $user->id,
-            "year_period_id" => $currentYearPeriod->id,
             "settlement_type" => SettlementType::Money->value,
             "state" => WaitingForTechnical::$name,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 7, 20)->format("Y-m-d H:i"),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 7, 23, 5)->format("Y-m-d H:i"),
+            "from" => Carbon::create($year, 2, 7, 20)->format("Y-m-d H:i"),
+            "to" => Carbon::create($year, 2, 7, 23, 5)->format("Y-m-d H:i"),
             "hours" => 4,
             "comment" => "Comment for the overtime request.",
         ]);
diff --git a/tests/Feature/SelectYearPeriodTest.php b/tests/Feature/SelectYearPeriodTest.php
deleted file mode 100644
index ef401906..00000000
--- a/tests/Feature/SelectYearPeriodTest.php
+++ /dev/null
@@ -1,53 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Feature;
-
-use Illuminate\Foundation\Testing\DatabaseMigrations;
-use Illuminate\Support\Carbon;
-use Tests\FeatureTestCase;
-use Toby\Helpers\YearPeriodRetriever;
-use Toby\Models\User;
-
-class SelectYearPeriodTest extends FeatureTestCase
-{
-    use DatabaseMigrations;
-
-    protected YearPeriodRetriever $yearPeriodRetriever;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        $this->yearPeriodRetriever = $this->app->make(YearPeriodRetriever::class);
-    }
-
-    public function testUserCanSelectNextYearPeriod(): void
-    {
-        $nextYearPeriod = $this->createYearPeriod(Carbon::now()->year + 1);
-        $user = User::factory()->create();
-
-        $this->actingAs($user)
-            ->post("/year-periods/{$nextYearPeriod->id}/select")
-            ->assertRedirect();
-
-        $this->assertSame($nextYearPeriod->id, $this->yearPeriodRetriever->selected()->id);
-    }
-
-    public function testUserCannotSelectNextYearPeriodIfDoesntExist(): void
-    {
-        $user = User::factory()->create();
-
-        $this->actingAs($user)
-            ->post("/year-periods/25/select")
-            ->assertNotFound();
-    }
-
-    public function testIfUserDoesntSelectAnyYearPeriodCurrentActsAsSelected(): void
-    {
-        $currentYearPeriod = $this->yearPeriodRetriever->current();
-
-        $this->assertSame($currentYearPeriod->id, $this->yearPeriodRetriever->selected()->id);
-    }
-}
diff --git a/tests/Feature/VacationLimitTest.php b/tests/Feature/VacationLimitTest.php
index 07511827..b284ecac 100644
--- a/tests/Feature/VacationLimitTest.php
+++ b/tests/Feature/VacationLimitTest.php
@@ -5,11 +5,11 @@
 namespace Tests\Feature;
 
 use Illuminate\Foundation\Testing\DatabaseMigrations;
+use Illuminate\Support\Carbon;
 use Inertia\Testing\AssertableInertia as Assert;
 use Tests\FeatureTestCase;
 use Toby\Models\User;
 use Toby\Models\VacationLimit;
-use Toby\Models\YearPeriod;
 
 class VacationLimitTest extends FeatureTestCase
 {
@@ -20,8 +20,7 @@ public function testAdminCanSeeVacationLimits(): void
         $admin = User::factory()->admin()->create();
 
         VacationLimit::factory(10)
-            ->for(YearPeriod::current())
-            ->create();
+            ->create(["year" => Carbon::now()->year]);
 
         $this->actingAs($admin)
             ->get("/vacation/limits")
@@ -29,7 +28,7 @@ public function testAdminCanSeeVacationLimits(): void
             ->assertInertia(
                 fn(Assert $page) => $page
                     ->component("VacationLimits")
-                    ->has("limits", 10),
+                    ->has("limits", 11),
             );
     }
 
@@ -37,23 +36,24 @@ public function testAdminCanUpdateVacationLimits(): void
     {
         $admin = User::factory()->admin()->create();
 
-        VacationLimit::factory(3)
-            ->for(YearPeriod::current())
-            ->create();
+        $year = Carbon::now()->year;
 
-        [$limit1, $limit2, $limit3] = VacationLimit::all();
+        [$user1, $user2, $user3] = User::factory(3)->create();
 
         $data = [
             [
-                "id" => $limit1->id,
+                "user" => $user1->id,
+                "year" => $year,
                 "days" => 25,
             ],
             [
-                "id" => $limit2->id,
+                "user" => $user2->id,
+                "year" => $year,
                 "days" => null,
             ],
             [
-                "id" => $limit3->id,
+                "user" => $user3->id,
+                "year" => $year,
                 "days" => 20,
             ],
         ];
@@ -65,17 +65,20 @@ public function testAdminCanUpdateVacationLimits(): void
             ->assertRedirect();
 
         $this->assertDatabaseHas("vacation_limits", [
-            "id" => $limit1->id,
+            "user_id" => $user1->id,
+            "year" => $year,
             "days" => 25,
         ]);
 
         $this->assertDatabaseHas("vacation_limits", [
-            "id" => $limit2->id,
+            "user_id" => $user2->id,
+            "year" => $year,
             "days" => null,
         ]);
 
         $this->assertDatabaseHas("vacation_limits", [
-            "id" => $limit3->id,
+            "user_id" => $user3->id,
+            "year" => $year,
             "days" => 20,
         ]);
     }
diff --git a/tests/Feature/VacationRequestTest.php b/tests/Feature/VacationRequestTest.php
index 722ea00d..7e7ca3b9 100644
--- a/tests/Feature/VacationRequestTest.php
+++ b/tests/Feature/VacationRequestTest.php
@@ -14,11 +14,11 @@
 use Toby\Domain\PolishHolidaysRetriever;
 use Toby\Enums\EmploymentForm;
 use Toby\Enums\VacationType;
+use Toby\Models\Holiday;
 use Toby\Models\Profile;
 use Toby\Models\User;
 use Toby\Models\VacationLimit;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 use Toby\States\VacationRequest\Approved;
 use Toby\States\VacationRequest\Cancelled;
 use Toby\States\VacationRequest\Rejected;
@@ -44,13 +44,13 @@ protected function setUp(): void
     public function testUserCanSeeVacationRequestsList(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $now = Carbon::now();
 
         VacationRequest::factory()
             ->count(10)
             ->for($user)
-            ->for($currentYearPeriod)
-            ->create();
+            ->create(["from" => $now]);
 
         $this->actingAs($user)
             ->get("/vacation/requests/me")
@@ -68,21 +68,21 @@ public function testUserCanCreateVacationRequest(): void
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 11)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 11)->toDateString(),
                 "comment" => "Comment for the vacation request.",
             ])
             ->assertSessionHasNoErrors()
@@ -90,11 +90,10 @@ public function testUserCanCreateVacationRequest(): void
 
         $this->assertDatabaseHas("vacation_requests", [
             "user_id" => $user->id,
-            "year_period_id" => $currentYearPeriod->id,
             "type" => VacationType::Vacation->value,
             "state" => WaitingForTechnical::$name,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 11)->toDateString(),
+            "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+            "to" => Carbon::create($currentYear, 2, 11)->toDateString(),
             "comment" => "Comment for the vacation request.",
         ]);
     }
@@ -106,21 +105,21 @@ public function testUserCanCreateVacationRequestOnEmployeeBehalf(): void
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($creator)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 11)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 11)->toDateString(),
                 "comment" => "Comment for the vacation request.",
             ])
             ->assertRedirect();
@@ -128,11 +127,10 @@ public function testUserCanCreateVacationRequestOnEmployeeBehalf(): void
         $this->assertDatabaseHas("vacation_requests", [
             "user_id" => $user->id,
             "creator_id" => $creator->id,
-            "year_period_id" => $currentYearPeriod->id,
             "type" => VacationType::Vacation->value,
             "state" => WaitingForTechnical::$name,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 11)->toDateString(),
+            "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+            "to" => Carbon::create($currentYear, 2, 11)->toDateString(),
             "comment" => "Comment for the vacation request.",
         ]);
     }
@@ -144,21 +142,21 @@ public function testUserCanCreateVacationRequestOnEmployeeBehalfAndSkipAcceptanc
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($creator)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 11)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 11)->toDateString(),
                 "comment" => "Comment for the vacation request.",
                 "flowSkipped" => true,
             ])
@@ -167,11 +165,10 @@ public function testUserCanCreateVacationRequestOnEmployeeBehalfAndSkipAcceptanc
         $this->assertDatabaseHas("vacation_requests", [
             "user_id" => $user->id,
             "creator_id" => $creator->id,
-            "year_period_id" => $currentYearPeriod->id,
             "type" => VacationType::Vacation->value,
             "state" => Approved::$name,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 11)->toDateString(),
+            "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+            "to" => Carbon::create($currentYear, 2, 11)->toDateString(),
             "comment" => "Comment for the vacation request.",
         ]);
     }
@@ -180,14 +177,12 @@ public function testTechnicalApproverCanApproveVacationRequest(): void
     {
         $user = User::factory()->create();
         $technicalApprover = User::factory()->technicalApprover()->create();
-        $currentYearPeriod = YearPeriod::current();
 
         $vacationRequest = VacationRequest::factory([
             "state" => WaitingForTechnical::class,
             "type" => VacationType::Vacation,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($technicalApprover)
@@ -204,13 +199,10 @@ public function testAdministrativeApproverCanApproveVacationRequest(): void
         $user = User::factory()->create();
         $administrativeApprover = User::factory()->administrativeApprover()->create();
 
-        $currentYearPeriod = YearPeriod::current();
-
         $vacationRequest = VacationRequest::factory([
             "state" => WaitingForAdministrative::class,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($administrativeApprover)
@@ -226,13 +218,14 @@ public function testTechnicalApproverCanRejectVacationRequest(): void
     {
         $user = User::factory()->create();
         $technicalApprover = User::factory()->technicalApprover()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         /** @var VacationRequest $vacationRequest */
@@ -241,7 +234,6 @@ public function testTechnicalApproverCanRejectVacationRequest(): void
             "type" => VacationType::Vacation,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($technicalApprover)
@@ -258,21 +250,21 @@ public function testUserCannotCreateVacationRequestIfHeExceedsHisVacationLimit()
         $user = User::factory()
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 3,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 11)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 11)->toDateString(),
                 "comment" => "Comment for the vacation request.",
             ])
             ->assertSessionHasErrors([
@@ -283,21 +275,22 @@ public function testUserCannotCreateVacationRequestIfHeExceedsHisVacationLimit()
     public function testUserCannotCreateVacationRequestAtWeekend(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 5)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 6)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 5)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 6)->toDateString(),
                 "comment" => "Vacation at weekend.",
             ])
             ->assertSessionHasErrors([
@@ -308,31 +301,31 @@ public function testUserCannotCreateVacationRequestAtWeekend(): void
     public function testUserCanCreateNonWorkDayVacationRequestAtWeekend(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Delegation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 5)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 6)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 5)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 6)->toDateString(),
                 "comment" => "Delegation at weekend.",
             ])
             ->assertRedirect();
 
         $this->assertDatabaseHas("vacation_requests", [
             "user_id" => $user->id,
-            "year_period_id" => $currentYearPeriod->id,
             "type" => VacationType::Delegation->value,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 5)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 6)->toDateString(),
+            "from" => Carbon::create($currentYear, 2, 5)->toDateString(),
+            "to" => Carbon::create($currentYear, 2, 6)->toDateString(),
             "comment" => "Delegation at weekend.",
         ]);
     }
@@ -340,17 +333,18 @@ public function testUserCanCreateNonWorkDayVacationRequestAtWeekend(): void
     public function testUserCannotCreateVacationRequestAtHoliday(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
-        foreach ($this->polishHolidaysRetriever->getForYearPeriod($currentYearPeriod) as $holiday) {
-            $currentYearPeriod->holidays()->create([
+        foreach ($this->polishHolidaysRetriever->getForYear($currentYear) as $holiday) {
+            Holiday::query()->create([
                 "name" => $holiday["name"],
                 "date" => $holiday["date"],
             ]);
@@ -360,8 +354,8 @@ public function testUserCannotCreateVacationRequestAtHoliday(): void
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
+                "from" => Carbon::create($currentYear, 4, 18)->toDateString(),
+                "to" => Carbon::create($currentYear, 4, 18)->toDateString(),
                 "comment" => "Vacation at holiday.",
             ])
             ->assertSessionHasErrors([
@@ -372,17 +366,18 @@ public function testUserCannotCreateVacationRequestAtHoliday(): void
     public function testUserCanCreateNonWorkDayVacationAtHoliday(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
-        foreach ($this->polishHolidaysRetriever->getForYearPeriod($currentYearPeriod) as $holiday) {
-            $currentYearPeriod->holidays()->create([
+        foreach ($this->polishHolidaysRetriever->getForYear($currentYear) as $holiday) {
+            Holiday::query()->create([
                 "name" => $holiday["name"],
                 "date" => $holiday["date"],
             ]);
@@ -392,18 +387,17 @@ public function testUserCanCreateNonWorkDayVacationAtHoliday(): void
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Delegation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
+                "from" => Carbon::create($currentYear, 4, 18)->toDateString(),
+                "to" => Carbon::create($currentYear, 4, 18)->toDateString(),
                 "comment" => "Delegation at holiday.",
             ])
             ->assertRedirect();
 
         $this->assertDatabaseHas("vacation_requests", [
             "user_id" => $user->id,
-            "year_period_id" => $currentYearPeriod->id,
             "type" => VacationType::Delegation->value,
-            "from" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 4, 18)->toDateString(),
+            "from" => Carbon::create($currentYear, 4, 18)->toDateString(),
+            "to" => Carbon::create($currentYear, 4, 18)->toDateString(),
             "comment" => "Delegation at holiday.",
         ]);
     }
@@ -413,32 +407,32 @@ public function testUserCannotCreateVacationRequestIfHeHasPendingVacationRequest
         $user = User::factory()
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         VacationRequest::factory([
             "type" => VacationType::Vacation->value,
             "state" => WaitingForTechnical::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 1)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+            "from" => Carbon::create($currentYear, 2, 1)->toDateString(),
+            "to" => Carbon::create($currentYear, 2, 4)->toDateString(),
             "comment" => "Comment for the vacation request.",
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 1)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 1)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 4)->toDateString(),
                 "comment" => "Another comment for the another vacation request.",
             ])
             ->assertSessionHasErrors([
@@ -451,32 +445,32 @@ public function testUserCannotCreateVacationRequestIfHeHasApprovedVacationReques
         $user = User::factory()
             ->has(Profile::factory(["employment_form" => EmploymentForm::EmploymentContract]))
             ->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         VacationRequest::factory([
             "type" => VacationType::Vacation->value,
             "state" => Approved::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 2)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+            "from" => Carbon::create($currentYear, 2, 2)->toDateString(),
+            "to" => Carbon::create($currentYear, 2, 4)->toDateString(),
             "comment" => "Comment for the vacation request.",
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 1)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 1)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 4)->toDateString(),
                 "comment" => "Another comment for the another vacation request.",
             ])
             ->assertSessionHasErrors([
@@ -487,13 +481,14 @@ public function testUserCannotCreateVacationRequestIfHeHasApprovedVacationReques
     public function testUserCannotCreateVacationRequestWithEndDatePriorToTheStartDate(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+        $currentYear = Carbon::now()->year;
+
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 6)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 6)->toDateString(),
                 "comment" => "Comment for the vacation request.",
             ])
             ->assertSessionHasErrors([
@@ -504,14 +499,15 @@ public function testUserCannotCreateVacationRequestWithEndDatePriorToTheStartDat
     public function testUserCannotCreateVacationRequestAtTheTurnOfTheYear(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
-        $nextYearPeriod = $this->createYearPeriod(Carbon::now()->year + 1);
+        $currentYear = Carbon::now()->year;
+        $nextYear = $currentYear + 1;
+
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $user->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 12, 27)->toDateString(),
-                "to" => Carbon::create($nextYearPeriod->year, 1, 2)->toDateString(),
+                "from" => Carbon::create($currentYear, 12, 27)->toDateString(),
+                "to" => Carbon::create($nextYear, 1, 2)->toDateString(),
                 "comment" => "Comment for the vacation request.",
             ])
             ->assertSessionHasErrors([
@@ -532,15 +528,14 @@ public function testEmployeeCannotCreateVacationRequestForAnotherEmployee(): voi
     {
         $user = User::factory()->create();
         $anotherUser = User::factory()->create();
-
-        $currentYearPeriod = YearPeriod::current();
+        $currentYear = Carbon::now()->year;
 
         $this->actingAs($user)
             ->post("/vacation/requests", [
                 "user" => $anotherUser->id,
                 "type" => VacationType::Vacation->value,
-                "from" => Carbon::create($currentYearPeriod->year, 2, 7)->toDateString(),
-                "to" => Carbon::create($currentYearPeriod->year, 2, 11)->toDateString(),
+                "from" => Carbon::create($currentYear, 2, 7)->toDateString(),
+                "to" => Carbon::create($currentYear, 2, 11)->toDateString(),
                 "comment" => "Comment for the vacation request.",
             ])
             ->assertForbidden();
@@ -549,13 +544,14 @@ public function testEmployeeCannotCreateVacationRequestForAnotherEmployee(): voi
     public function testEmployeeCanCancelVacationRequestWithWaitingForAdministrativeStatus(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         /** @var VacationRequest $vacationRequest */
@@ -564,7 +560,6 @@ public function testEmployeeCanCancelVacationRequestWithWaitingForAdministrative
             "type" => VacationType::Vacation,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
@@ -579,13 +574,14 @@ public function testEmployeeCanCancelVacationRequestWithWaitingForAdministrative
     public function testEmployeeCannotCancelVacationRequestWithApprovedStatus(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         /** @var VacationRequest $vacationRequest */
@@ -594,7 +590,6 @@ public function testEmployeeCannotCancelVacationRequestWithApprovedStatus(): voi
             "type" => VacationType::Vacation,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
@@ -605,13 +600,14 @@ public function testEmployeeCannotCancelVacationRequestWithApprovedStatus(): voi
     public function testTechnicalApproverCanCancelVacationRequestWithApprovedStatus(): void
     {
         $user = User::factory()->technicalApprover()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         /** @var VacationRequest $vacationRequest */
@@ -620,7 +616,6 @@ public function testTechnicalApproverCanCancelVacationRequestWithApprovedStatus(
             "type" => VacationType::Vacation,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
@@ -635,7 +630,6 @@ public function testTechnicalApproverCanCancelVacationRequestWithApprovedStatus(
     public function testEmployeeCanCancelRemoteWorkEvenWithApprovedStatus(): void
     {
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
 
         /** @var VacationRequest $vacationRequest */
         $vacationRequest = VacationRequest::factory([
@@ -643,7 +637,6 @@ public function testEmployeeCanCancelRemoteWorkEvenWithApprovedStatus(): void
             "type" => VacationType::RemoteWork,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
@@ -659,13 +652,14 @@ public function testAdministrativeApproverCanCancelVacationRequestWithApprovedSt
     {
         $user = User::factory()->create();
         $administrativeApprover = User::factory()->administrativeApprover()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         /** @var VacationRequest $vacationRequest */
@@ -674,7 +668,6 @@ public function testAdministrativeApproverCanCancelVacationRequestWithApprovedSt
             "type" => VacationType::Vacation,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($administrativeApprover)
@@ -690,13 +683,16 @@ public function testEmployeeCanDownloadHisVacationRequestAsPdf(): void
     {
         Storage::fake();
         $user = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $this->withoutExceptionHandling();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         /** @var VacationRequest $vacationRequest */
@@ -705,7 +701,6 @@ public function testEmployeeCanDownloadHisVacationRequestAsPdf(): void
             "type" => VacationType::Vacation,
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
@@ -718,13 +713,14 @@ public function testEmployeeCannotDownloadAnotherEmployeesVacationRequestAsPdf()
         Storage::fake();
         $user = User::factory()->create();
         $anotherUser = User::factory()->create();
-        $currentYearPeriod = YearPeriod::current();
+
+        $currentYear = Carbon::now()->year;
 
         VacationLimit::factory([
             "days" => 20,
+            "year" => $currentYear,
         ])
             ->for($anotherUser)
-            ->for($currentYearPeriod)
             ->create();
 
         /** @var VacationRequest $vacationRequest */
@@ -733,7 +729,6 @@ public function testEmployeeCannotDownloadAnotherEmployeesVacationRequestAsPdf()
             "type" => VacationType::Vacation,
         ])
             ->for($anotherUser)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->actingAs($user)
diff --git a/tests/FeatureTestCase.php b/tests/FeatureTestCase.php
index 4943dd5f..4fc7bda8 100644
--- a/tests/FeatureTestCase.php
+++ b/tests/FeatureTestCase.php
@@ -7,13 +7,11 @@
 use Database\Seeders\PermissionsSeeder;
 use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
 use Illuminate\Support\Carbon;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Models\BenefitsReport;
 
 abstract class FeatureTestCase extends BaseTestCase
 {
     use CreatesApplication;
-    use InteractsWithYearPeriods;
 
     protected function setUp(): void
     {
@@ -22,7 +20,6 @@ protected function setUp(): void
         $this->withoutVite();
 
         Carbon::setTestNow(Carbon::createFromDate(2022, 1, 1));
-        $this->createCurrentYearPeriod();
 
         BenefitsReport::factory()->create([
             "name" => "current",
diff --git a/tests/Traits/InteractsWithYearPeriods.php b/tests/Traits/InteractsWithYearPeriods.php
deleted file mode 100644
index fb74ab3d..00000000
--- a/tests/Traits/InteractsWithYearPeriods.php
+++ /dev/null
@@ -1,49 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Traits;
-
-use Illuminate\Foundation\Testing\Concerns\InteractsWithSession;
-use Illuminate\Support\Carbon;
-use Toby\Helpers\YearPeriodRetriever;
-use Toby\Models\YearPeriod;
-
-trait InteractsWithYearPeriods
-{
-    use InteractsWithSession;
-
-    public function createYearPeriod(int $year): YearPeriod
-    {
-        /** @var YearPeriod $yearPeriod */
-        $yearPeriod = YearPeriod::factory()->create([
-            "year" => $year,
-        ]);
-
-        return $yearPeriod;
-    }
-
-    public function createCurrentYearPeriod(): YearPeriod
-    {
-        return $this->createYearPeriod(Carbon::now()->year);
-    }
-
-    public function markYearPeriodAsSelected(YearPeriod $yearPeriod): void
-    {
-        $this->session([
-            YearPeriodRetriever::SESSION_KEY => $yearPeriod->id,
-        ]);
-    }
-
-    public function clearSelectedYearPeriod(): void
-    {
-        $this->session([]);
-    }
-
-    public function cleanYearPeriods(): void
-    {
-        $this->clearSelectedYearPeriod();
-
-        YearPeriod::query()->delete();
-    }
-}
diff --git a/tests/Unit/CheckYearPeriodTest.php b/tests/Unit/CheckYearPeriodTest.php
deleted file mode 100644
index b258e840..00000000
--- a/tests/Unit/CheckYearPeriodTest.php
+++ /dev/null
@@ -1,100 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Unit;
-
-use Illuminate\Foundation\Testing\RefreshDatabase;
-use Illuminate\Support\Carbon;
-use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
-use Toby\Jobs\CheckYearPeriod;
-
-class CheckYearPeriodTest extends TestCase
-{
-    use RefreshDatabase;
-    use InteractsWithYearPeriods;
-
-    public function testYearPeriodsAreCreatedWhenDontExist(): void
-    {
-        $now = Carbon::now();
-
-        Carbon::setTestNow($now);
-
-        CheckYearPeriod::dispatchSync();
-
-        $this->assertDatabaseCount("year_periods", 2);
-
-        $this->assertDatabaseHas("year_periods", [
-            "year" => $now->year,
-        ]);
-
-        $this->assertDatabaseHas("year_periods", [
-            "year" => $now->year + 1,
-        ]);
-    }
-
-    public function testCurrentYearPeriodIsCreatedWhenDoesntExist(): void
-    {
-        $now = Carbon::now();
-        Carbon::setTestNow($now);
-
-        $this->assertDatabaseMissing("year_periods", [
-            "year" => $now->year,
-        ]);
-
-        CheckYearPeriod::dispatchSync();
-
-        $this->assertDatabaseHas("year_periods", [
-            "year" => $now->year,
-        ]);
-    }
-
-    public function testNextYearPeriodIsCreatedWhenDoesntExist(): void
-    {
-        $now = Carbon::now();
-        Carbon::setTestNow($now);
-
-        $this->createCurrentYearPeriod();
-
-        $this->assertDatabaseMissing("year_periods", [
-            "year" => $now->year + 1,
-        ]);
-
-        CheckYearPeriod::dispatchSync();
-
-        $this->assertDatabaseHas("year_periods", [
-            "year" => $now->year + 1,
-        ]);
-    }
-
-    public function testYearPeriodsAreNotCreatedWhenExists(): void
-    {
-        $now = Carbon::now();
-        Carbon::setTestNow($now);
-
-        $this->createCurrentYearPeriod();
-        $this->createYearPeriod($now->year + 1);
-
-        $this->assertDatabaseCount("year_periods", 2);
-
-        CheckYearPeriod::dispatchSync();
-
-        $this->assertDatabaseCount("year_periods", 2);
-    }
-
-    public function testYearPeriodsAreNotDuplicatedWhenJobCalledMultipleTimes(): void
-    {
-        $now = Carbon::now();
-        Carbon::setTestNow($now);
-
-        CheckYearPeriod::dispatchSync();
-        $this->assertDatabaseCount("year_periods", 2);
-
-        CheckYearPeriod::dispatchSync();
-        CheckYearPeriod::dispatchSync();
-        CheckYearPeriod::dispatchSync();
-
-        $this->assertDatabaseCount("year_periods", 2);
-    }
-}
diff --git a/tests/Unit/SendDailySummaryToSlackTest.php b/tests/Unit/SendDailySummaryToSlackTest.php
index 740eb929..82d612f3 100644
--- a/tests/Unit/SendDailySummaryToSlackTest.php
+++ b/tests/Unit/SendDailySummaryToSlackTest.php
@@ -9,14 +9,12 @@
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Str;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Console\Commands\SendDailySummaryToSlack;
 use Toby\Models\Holiday;
 
 class SendDailySummaryToSlackTest extends TestCase
 {
     use RefreshDatabase;
-    use InteractsWithYearPeriods;
 
     protected function setUp(): void
     {
@@ -26,7 +24,6 @@ protected function setUp(): void
             "channel" => Str::random(8),
             "message" => ["ts" => Carbon::now()->toDateTimeString()],
         ]);
-        $this->createCurrentYearPeriod();
     }
 
     public function testCommandSendsMessageToSlackIfWeekday(): void
diff --git a/tests/Unit/SendNotificationAboutUpcomingMedicalExamsToSlackTest.php b/tests/Unit/SendNotificationAboutUpcomingMedicalExamsToSlackTest.php
index b6655d80..160b3402 100644
--- a/tests/Unit/SendNotificationAboutUpcomingMedicalExamsToSlackTest.php
+++ b/tests/Unit/SendNotificationAboutUpcomingMedicalExamsToSlackTest.php
@@ -8,7 +8,6 @@
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\Notification;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Console\Commands\SendNotificationAboutUpcomingMedicalExamsForEmployees;
 use Toby\Models\User;
 use Toby\Notifications\UpcomingMedicalExamForEmployeeNotification;
@@ -16,7 +15,6 @@
 class SendNotificationAboutUpcomingMedicalExamsToSlackTest extends TestCase
 {
     use RefreshDatabase;
-    use InteractsWithYearPeriods;
 
     protected User $user;
 
@@ -25,7 +23,6 @@ protected function setUp(): void
         parent::setUp();
 
         Notification::fake();
-        $this->createCurrentYearPeriod();
         $this->user = User::factory()->employee()->create();
     }
 
diff --git a/tests/Unit/SendNotificationAboutUpcomingOhsTrainingsToSlackTest.php b/tests/Unit/SendNotificationAboutUpcomingOhsTrainingsToSlackTest.php
index 0c6442c1..689e3f40 100644
--- a/tests/Unit/SendNotificationAboutUpcomingOhsTrainingsToSlackTest.php
+++ b/tests/Unit/SendNotificationAboutUpcomingOhsTrainingsToSlackTest.php
@@ -10,7 +10,6 @@
 use Illuminate\Support\Facades\Notification;
 use Illuminate\Support\Str;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Console\Commands\SendNotificationAboutUpcomingOhsTrainingsForEmployees;
 use Toby\Models\User;
 use Toby\Notifications\UpcomingOhsTrainingForEmployeeNotification;
@@ -18,7 +17,6 @@
 class SendNotificationAboutUpcomingOhsTrainingsToSlackTest extends TestCase
 {
     use RefreshDatabase;
-    use InteractsWithYearPeriods;
 
     protected User $user;
 
@@ -27,7 +25,6 @@ protected function setUp(): void
         parent::setUp();
 
         Notification::fake();
-        $this->createCurrentYearPeriod();
         Http::fake(fn(): array => [
             "channel" => Str::random(8),
             "message" => ["ts" => Carbon::now()->toDateTimeString()],
diff --git a/tests/Unit/SendOvertimeRequestSummariesTest.php b/tests/Unit/SendOvertimeRequestSummariesTest.php
index 2cd2f358..143d50fc 100644
--- a/tests/Unit/SendOvertimeRequestSummariesTest.php
+++ b/tests/Unit/SendOvertimeRequestSummariesTest.php
@@ -7,11 +7,9 @@
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\Notification;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Console\Commands\SendOvertimeRequestSummariesToApprovers;
 use Toby\Models\OvertimeRequest;
 use Toby\Models\User;
-use Toby\Models\YearPeriod;
 use Toby\Notifications\OvertimeRequestsSummaryNotification;
 use Toby\States\OvertimeRequest\Approved;
 use Toby\States\OvertimeRequest\Cancelled;
@@ -23,21 +21,17 @@
 class SendOvertimeRequestSummariesTest extends TestCase
 {
     use RefreshDatabase;
-    use InteractsWithYearPeriods;
 
     protected function setUp(): void
     {
         parent::setUp();
 
         Notification::fake();
-        $this->createCurrentYearPeriod();
         $this->travelTo(now()->startOfWeek());
     }
 
     public function testSummariesAreSentOnlyToProperApprovers(): void
     {
-        $currentYearPeriod = YearPeriod::current();
-
         $user = User::factory()->employee()->create();
         $technicalApprover = User::factory()->technicalApprover()->create();
         $administrativeApprover = User::factory()->administrativeApprover()->create();
@@ -45,7 +39,6 @@ public function testSummariesAreSentOnlyToProperApprovers(): void
 
         OvertimeRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => WaitingForTechnical::class]);
 
         $this->artisan(SendOvertimeRequestSummariesToApprovers::class)
@@ -58,13 +51,11 @@ public function testSummariesAreSentOnlyToProperApprovers(): void
     public function testSummariesAreNotSentOnWeekends(): void
     {
         $this->travelTo(now()->endOfWeek());
-        $currentYearPeriod = YearPeriod::current();
 
         $user = User::factory()->employee()->create();
 
         OvertimeRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => WaitingForTechnical::class]);
 
         $this->artisan(SendOvertimeRequestSummariesToApprovers::class)
@@ -75,15 +66,12 @@ public function testSummariesAreNotSentOnWeekends(): void
 
     public function testSummariesAreSentOnlyIfOvertimeRequestWaitingForActionExists(): void
     {
-        $currentYearPeriod = YearPeriod::current();
-
         $user = User::factory()->employee()->create();
         $technicalApprover = User::factory()->technicalApprover()->create();
         $admin = User::factory()->admin()->create();
 
         OvertimeRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => WaitingForTechnical::class]);
 
         $this->artisan(SendOvertimeRequestSummariesToApprovers::class)
@@ -95,35 +83,28 @@ public function testSummariesAreSentOnlyIfOvertimeRequestWaitingForActionExists(
 
     public function testSummariesAreNotSentIfThereAreNoWaitingForActionOvertimeRequests(): void
     {
-        $currentYearPeriod = YearPeriod::current();
-
         $user = User::factory()->employee()->create();
         $technicalApprover = User::factory()->technicalApprover()->create();
         $admin = User::factory()->admin()->create();
 
         OvertimeRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Approved::class]);
 
         OvertimeRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Cancelled::class]);
 
         OvertimeRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Rejected::class]);
 
         OvertimeRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Created::class]);
 
         OvertimeRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Settled::class]);
 
         $this->artisan(SendOvertimeRequestSummariesToApprovers::class)
diff --git a/tests/Unit/SendVacationRequestSummariesTest.php b/tests/Unit/SendVacationRequestSummariesTest.php
index e42b3a4f..dfad3640 100644
--- a/tests/Unit/SendVacationRequestSummariesTest.php
+++ b/tests/Unit/SendVacationRequestSummariesTest.php
@@ -7,11 +7,9 @@
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\Notification;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Console\Commands\SendVacationRequestSummariesToApprovers;
 use Toby\Models\User;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 use Toby\Notifications\VacationRequestsSummaryNotification;
 use Toby\States\VacationRequest\Approved;
 use Toby\States\VacationRequest\Cancelled;
@@ -22,21 +20,17 @@
 class SendVacationRequestSummariesTest extends TestCase
 {
     use RefreshDatabase;
-    use InteractsWithYearPeriods;
 
     protected function setUp(): void
     {
         parent::setUp();
 
         Notification::fake();
-        $this->createCurrentYearPeriod();
         $this->travelTo(now()->startOfWeek());
     }
 
     public function testSummariesAreSentOnlyToProperApprovers(): void
     {
-        $currentYearPeriod = YearPeriod::current();
-
         $user = User::factory()->employee()->create();
         $technicalApprover = User::factory()->technicalApprover()->create();
         $administrativeApprover = User::factory()->administrativeApprover()->create();
@@ -44,7 +38,6 @@ public function testSummariesAreSentOnlyToProperApprovers(): void
 
         VacationRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => WaitingForTechnical::class]);
 
         $this->artisan(SendVacationRequestSummariesToApprovers::class)
@@ -57,13 +50,11 @@ public function testSummariesAreSentOnlyToProperApprovers(): void
     public function testSummariesAreNotSentOnWeekends(): void
     {
         $this->travelTo(now()->endOfWeek());
-        $currentYearPeriod = YearPeriod::current();
 
         $user = User::factory()->employee()->create();
 
         VacationRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => WaitingForTechnical::class]);
 
         $this->artisan(SendVacationRequestSummariesToApprovers::class)
@@ -74,15 +65,12 @@ public function testSummariesAreNotSentOnWeekends(): void
 
     public function testSummariesAreSentOnlyIfVacationRequestWaitingForActionExists(): void
     {
-        $currentYearPeriod = YearPeriod::current();
-
         $user = User::factory()->employee()->create();
         $technicalApprover = User::factory()->technicalApprover()->create();
         $admin = User::factory()->admin()->create();
 
         VacationRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => WaitingForTechnical::class]);
 
         $this->artisan(SendVacationRequestSummariesToApprovers::class)
@@ -94,30 +82,24 @@ public function testSummariesAreSentOnlyIfVacationRequestWaitingForActionExists(
 
     public function testSummariesAreNotSentIfThereAreNoWaitingForActionVacationRequests(): void
     {
-        $currentYearPeriod = YearPeriod::current();
-
         $user = User::factory()->employee()->create();
         $technicalApprover = User::factory()->technicalApprover()->create();
         $admin = User::factory()->admin()->create();
 
         VacationRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Approved::class]);
 
         VacationRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Cancelled::class]);
 
         VacationRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Rejected::class]);
 
         VacationRequest::factory()
             ->for($user)
-            ->for($currentYearPeriod)
             ->create(["state" => Created::class]);
 
         $this->artisan(SendVacationRequestSummariesToApprovers::class)
diff --git a/tests/Unit/UnavailableDaysRetrieverTest.php b/tests/Unit/UnavailableDaysRetrieverTest.php
index 8d0d970c..50d4a8e2 100644
--- a/tests/Unit/UnavailableDaysRetrieverTest.php
+++ b/tests/Unit/UnavailableDaysRetrieverTest.php
@@ -9,26 +9,23 @@
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Carbon;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Domain\PolishHolidaysRetriever;
 use Toby\Domain\UnavailableDaysRetriever;
 use Toby\Enums\Role;
 use Toby\Enums\VacationType;
+use Toby\Models\Holiday;
 use Toby\Models\User;
 use Toby\Models\Vacation;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 use Toby\States\VacationRequest\Approved;
 
 class UnavailableDaysRetrieverTest extends TestCase
 {
     use RefreshDatabase;
     use InteractsWithSession;
-    use InteractsWithYearPeriods;
 
     public UnavailableDaysRetriever $unavailableDaysRetriever;
     public User $user;
-    public YearPeriod $yearPeriod;
 
     protected function setUp(): void
     {
@@ -36,11 +33,9 @@ protected function setUp(): void
 
         $this->unavailableDaysRetriever = $this->app->make(UnavailableDaysRetriever::class);
         $this->user = User::factory(["role" => Role::Employee])->create();
-        $this->yearPeriod = $this->createYearPeriod(2023);
 
         $vacationRequest = VacationRequest::factory()
             ->for($this->user)
-            ->for($this->yearPeriod)
             ->create([
                 "from" => Carbon::parse("2023-07-05"),
                 "to" => Carbon::parse("2023-07-09"),
@@ -49,7 +44,6 @@ protected function setUp(): void
 
         Vacation::factory()
             ->for($vacationRequest)
-            ->for($this->yearPeriod)
             ->for($this->user)
             ->count(5)
             ->state(new Sequence(
@@ -63,8 +57,8 @@ protected function setUp(): void
 
         $polishHolidaysRetriever = $this->app->make(PolishHolidaysRetriever::class);
 
-        foreach ($polishHolidaysRetriever->getForYearPeriod($this->yearPeriod) as $holiday) {
-            $this->yearPeriod->holidays()->create([
+        foreach ($polishHolidaysRetriever->getForYear(2023) as $holiday) {
+            Holiday::query()->create([
                 "name" => $holiday["name"],
                 "date" => $holiday["date"],
             ]);
@@ -193,7 +187,7 @@ public function testRetrievesCorrectUnavailableDays(): void
             "2023-12-31",
         ];
 
-        $actualUnavailableDays = $this->unavailableDaysRetriever->getUnavailableDays($this->user, $this->yearPeriod)
+        $actualUnavailableDays = $this->unavailableDaysRetriever->getUnavailableDays($this->user, 2023)
             ->map(fn(Carbon $date): string => $date->toDateString())
             ->toArray();
 
@@ -211,7 +205,7 @@ public function testRetrievesCorrectUnavailableDaysForNonWorkDaysVacation(): voi
         ];
 
         $actualUnavailableDays = $this->unavailableDaysRetriever
-            ->getUnavailableDays($this->user, $this->yearPeriod, VacationType::Delegation)
+            ->getUnavailableDays($this->user, 2023, VacationType::Delegation)
             ->map(fn(Carbon $date): string => $date->toDateString())
             ->toArray();
 
diff --git a/tests/Unit/VacationLimitTest.php b/tests/Unit/VacationLimitTest.php
deleted file mode 100644
index 5d65cd33..00000000
--- a/tests/Unit/VacationLimitTest.php
+++ /dev/null
@@ -1,60 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Unit;
-
-use Illuminate\Foundation\Testing\DatabaseMigrations;
-use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
-use Toby\Actions\CreateUserAction;
-use Toby\Actions\CreateYearPeriodAction;
-use Toby\Models\Profile;
-use Toby\Models\User;
-use Toby\Models\YearPeriod;
-
-class VacationLimitTest extends TestCase
-{
-    use DatabaseMigrations;
-    use InteractsWithYearPeriods;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        $this->createCurrentYearPeriod();
-    }
-
-    public function testWhenUserIsCreatedThenVacationLimitIsCreatedForCurrentYearPeriod(): void
-    {
-        $this->assertDatabaseCount("vacation_limits", 0);
-
-        $currentYearPeriod = YearPeriod::current();
-        $createUserAction = $this->app->make(CreateUserAction::class);
-
-        $dumpUserData = User::factory()->raw();
-        $dumpProfileData = Profile::factory()->raw();
-
-        $user = $createUserAction->execute($dumpUserData, $dumpProfileData);
-
-        $this->assertDatabaseCount("vacation_limits", 1);
-
-        $this->assertDatabaseHas("vacation_limits", [
-            "user_id" => $user->id,
-            "year_period_id" => $currentYearPeriod->id,
-        ]);
-    }
-
-    public function testWhenYearPeriodIsCreatedThenVacationLimitsForThisYearPeriodAreCreated(): void
-    {
-        $this->assertDatabaseCount("vacation_limits", 0);
-        $createYearPeriodAction = $this->app->make(CreateYearPeriodAction::class);
-        $lastYear = YearPeriod::query()->max("year") + 1;
-
-        User::factory(10)->create();
-
-        $createYearPeriodAction->execute($lastYear);
-
-        $this->assertDatabaseCount("vacation_limits", 10);
-    }
-}
diff --git a/tests/Unit/VacationRequestNotificationTest.php b/tests/Unit/VacationRequestNotificationTest.php
index 94a3782f..0bce354c 100644
--- a/tests/Unit/VacationRequestNotificationTest.php
+++ b/tests/Unit/VacationRequestNotificationTest.php
@@ -8,13 +8,11 @@
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\Notification;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Actions\VacationRequest\RejectAction;
 use Toby\Actions\VacationRequest\WaitForTechApprovalAction;
 use Toby\Enums\VacationType;
 use Toby\Models\User;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 use Toby\Notifications\VacationRequestStatusChangedNotification;
 use Toby\Notifications\VacationRequestWaitsForApprovalNotification;
 use Toby\States\VacationRequest\Created;
@@ -23,14 +21,6 @@
 class VacationRequestNotificationTest extends TestCase
 {
     use DatabaseMigrations;
-    use InteractsWithYearPeriods;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        $this->createCurrentYearPeriod();
-    }
 
     public function testAfterChangingVacationRequestStateNotificationAreSentToUsers(): void
     {
@@ -41,18 +31,17 @@ public function testAfterChangingVacationRequestStateNotificationAreSentToUsers(
         $administrativeApprover = User::factory()->administrativeApprover()->create();
         $admin = User::factory()->admin()->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = Carbon::now()->year;
 
         /** @var VacationRequest $vacationRequest */
         $vacationRequest = VacationRequest::factory([
             "type" => VacationType::Vacation->value,
             "state" => Created::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 1)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+            "from" => Carbon::create($year, 2, 1)->toDateString(),
+            "to" => Carbon::create($year, 2, 4)->toDateString(),
             "comment" => "Comment for the vacation request.",
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $waitForTechApprovalAction = $this->app->make(WaitForTechApprovalAction::class);
@@ -71,18 +60,17 @@ public function testNotificationIsSentOnceToUser(): void
         $administrativeApprover = User::factory()->administrativeApprover()->create();
         $admin = User::factory()->admin()->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = Carbon::now()->year;
 
         /** @var VacationRequest $vacationRequest */
         $vacationRequest = VacationRequest::factory([
             "type" => VacationType::Vacation->value,
             "state" => WaitingForTechnical::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 1)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+            "from" => Carbon::create($year, 2, 1)->toDateString(),
+            "to" => Carbon::create($year, 2, 4)->toDateString(),
             "comment" => "Comment for the vacation request.",
         ])
             ->for($administrativeApprover)
-            ->for($currentYearPeriod)
             ->create();
 
         $rejectAction = $this->app->make(RejectAction::class);
diff --git a/tests/Unit/VacationRequestStatesTest.php b/tests/Unit/VacationRequestStatesTest.php
index a6de0f19..9126dd69 100644
--- a/tests/Unit/VacationRequestStatesTest.php
+++ b/tests/Unit/VacationRequestStatesTest.php
@@ -9,12 +9,10 @@
 use Illuminate\Support\Facades\Bus;
 use Illuminate\Support\Facades\Notification;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Domain\VacationRequestStateManager;
 use Toby\Enums\VacationType;
 use Toby\Models\User;
 use Toby\Models\VacationRequest;
-use Toby\Models\YearPeriod;
 use Toby\States\VacationRequest\Approved;
 use Toby\States\VacationRequest\Created;
 use Toby\States\VacationRequest\WaitingForTechnical;
@@ -22,7 +20,6 @@
 class VacationRequestStatesTest extends TestCase
 {
     use DatabaseMigrations;
-    use InteractsWithYearPeriods;
 
     protected VacationRequestStateManager $stateManager;
 
@@ -34,26 +31,23 @@ protected function setUp(): void
         Bus::fake();
 
         $this->stateManager = $this->app->make(VacationRequestStateManager::class);
-
-        $this->createCurrentYearPeriod();
     }
 
     public function testAfterCreatingVacationRequestOfTypeVacationItTransitsToProperState(): void
     {
         $user = User::factory()->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = 2022;
 
         /** @var VacationRequest $vacationRequest */
         $vacationRequest = VacationRequest::factory([
             "type" => VacationType::Vacation->value,
             "state" => Created::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 1)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+            "from" => Carbon::create($year, 2, 1)->toDateString(),
+            "to" => Carbon::create($year, 2, 4)->toDateString(),
             "comment" => "Comment for the vacation request.",
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->stateManager->waitForTechnical($vacationRequest);
@@ -65,17 +59,16 @@ public function testAfterCreatingVacationRequestOfTypeSickVacationItTransitsToPr
     {
         $user = User::factory()->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = 2022;
 
         /** @var VacationRequest $vacationRequest */
         $vacationRequest = VacationRequest::factory([
             "type" => VacationType::Sick->value,
             "state" => Created::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 1)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 4)->toDateString(),
+            "from" => Carbon::create($year, 2, 1)->toDateString(),
+            "to" => Carbon::create($year, 2, 4)->toDateString(),
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->stateManager->approve($vacationRequest);
@@ -87,17 +80,16 @@ public function testAfterCreatingVacationRequestOfTypeTimeInLieuItTransitsToProp
     {
         $user = User::factory()->create();
 
-        $currentYearPeriod = YearPeriod::current();
+        $year = 2022;
 
         /** @var VacationRequest $vacationRequest */
         $vacationRequest = VacationRequest::factory([
             "type" => VacationType::TimeInLieu->value,
             "state" => Created::class,
-            "from" => Carbon::create($currentYearPeriod->year, 2, 2)->toDateString(),
-            "to" => Carbon::create($currentYearPeriod->year, 2, 2)->toDateString(),
+            "from" => Carbon::create($year, 2, 2)->toDateString(),
+            "to" => Carbon::create($year, 2, 2)->toDateString(),
         ])
             ->for($user)
-            ->for($currentYearPeriod)
             ->create();
 
         $this->stateManager->approve($vacationRequest);
diff --git a/tests/Unit/WorkDaysCalculatorTest.php b/tests/Unit/WorkDaysCalculatorTest.php
index 601672d4..ec44136e 100644
--- a/tests/Unit/WorkDaysCalculatorTest.php
+++ b/tests/Unit/WorkDaysCalculatorTest.php
@@ -8,16 +8,15 @@
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Carbon;
 use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
 use Toby\Domain\PolishHolidaysRetriever;
 use Toby\Domain\WorkDaysCalculator;
 use Toby\Enums\VacationType;
+use Toby\Models\Holiday;
 
 class WorkDaysCalculatorTest extends TestCase
 {
     use RefreshDatabase;
     use InteractsWithSession;
-    use InteractsWithYearPeriods;
 
     public WorkDaysCalculator $workDaysCalculator;
 
@@ -27,12 +26,10 @@ protected function setUp(): void
 
         $this->workDaysCalculator = $this->app->make(WorkDaysCalculator::class);
 
-        $yearPeriod = $this->createYearPeriod(2023);
-
         $polishHolidaysRetriever = $this->app->make(PolishHolidaysRetriever::class);
 
-        foreach ($polishHolidaysRetriever->getForYearPeriod($yearPeriod) as $holiday) {
-            $yearPeriod->holidays()->create([
+        foreach ($polishHolidaysRetriever->getForYear(2023) as $holiday) {
+            Holiday::query()->create([
                 "name" => $holiday["name"],
                 "date" => $holiday["date"],
             ]);
diff --git a/tests/Unit/YearPeriodExistsRuleTest.php b/tests/Unit/YearPeriodExistsRuleTest.php
deleted file mode 100644
index 2e10ae7e..00000000
--- a/tests/Unit/YearPeriodExistsRuleTest.php
+++ /dev/null
@@ -1,61 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Unit;
-
-use Illuminate\Foundation\Testing\RefreshDatabase;
-use Illuminate\Support\Carbon;
-use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
-use Toby\Http\Rules\YearPeriodExists;
-
-class YearPeriodExistsRuleTest extends TestCase
-{
-    use RefreshDatabase;
-    use InteractsWithYearPeriods;
-
-    protected YearPeriodExists $rule;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        $this->rule = $this->app->make(YearPeriodExists::class);
-    }
-
-    public function testItPassesIfYearPeriodExists(): void
-    {
-        $now = Carbon::now();
-        Carbon::setTestNow($now);
-
-        $this->createCurrentYearPeriod();
-
-        $fail = false;
-        $value = $now->year;
-
-        $this->rule->validate("year", $value, function () use (&$fail): void {
-            $fail = true;
-        });
-        $this->assertFalse($fail, "The year period for given year does not exist.");
-    }
-
-    public function testItFailsIfYearPeriodDoesNotExist(): void
-    {
-        $now = Carbon::now();
-        Carbon::setTestNow($now);
-
-        $invalidValues = [
-            $now->year,
-            null,
-        ];
-
-        foreach ($invalidValues as $value) {
-            $fail = false;
-            $this->rule->validate("year", $value, static function () use (&$fail): void {
-                $fail = true;
-            });
-            $this->assertTrue($fail, "The year period for given year does not exist.");
-        }
-    }
-}
diff --git a/tests/Unit/YearPeriodRetrieverTest.php b/tests/Unit/YearPeriodRetrieverTest.php
deleted file mode 100644
index c760d5c1..00000000
--- a/tests/Unit/YearPeriodRetrieverTest.php
+++ /dev/null
@@ -1,89 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\Unit;
-
-use Illuminate\Foundation\Testing\Concerns\InteractsWithSession;
-use Illuminate\Foundation\Testing\RefreshDatabase;
-use Illuminate\Support\Carbon;
-use Tests\TestCase;
-use Tests\Traits\InteractsWithYearPeriods;
-use Toby\Helpers\YearPeriodRetriever;
-use Toby\Models\YearPeriod;
-
-class YearPeriodRetrieverTest extends TestCase
-{
-    use RefreshDatabase;
-    use InteractsWithSession;
-    use InteractsWithYearPeriods;
-
-    public Carbon $current;
-    public YearPeriod $previousYearPeriod;
-    public YearPeriod $currentYearPeriod;
-    public YearPeriod $nextYearPeriod;
-    public YearPeriodRetriever $yearPeriodRetriever;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        $this->current = Carbon::now();
-        Carbon::setTestNow($this->current);
-
-        $this->yearPeriodRetriever = $this->app->make(YearPeriodRetriever::class);
-
-        $this->previousYearPeriod = $this->createYearPeriod($this->current->year - 1);
-        $this->currentYearPeriod = $this->createCurrentYearPeriod();
-        $this->nextYearPeriod = $this->createYearPeriod($this->current->year + 1);
-    }
-
-    public function testRetrievesCorrectCurrentYearPeriod(): void
-    {
-        $this->assertSame($this->currentYearPeriod->id, $this->yearPeriodRetriever->current()->id);
-    }
-
-    public function testRetrievesCurrentYearPeriodWhenNoneIsSelected(): void
-    {
-        $this->clearSelectedYearPeriod();
-
-        $this->assertSame($this->currentYearPeriod->id, $this->yearPeriodRetriever->selected()->id);
-    }
-
-    public function testRetrievesCorrectYearPeriodWhenSelected(): void
-    {
-        $this->markYearPeriodAsSelected($this->nextYearPeriod);
-
-        $this->assertSame($this->nextYearPeriod->id, $this->yearPeriodRetriever->selected()->id);
-    }
-
-    public function testLinks(): void
-    {
-        $expected = [
-            "current" => [
-                "year" => $this->currentYearPeriod->year,
-                "link" => route("year-periods.select", $this->currentYearPeriod),
-            ],
-            "selected" => [
-                "year" => $this->currentYearPeriod->year,
-                "link" => route("year-periods.select", $this->currentYearPeriod),
-            ],
-            "navigation" => [
-                [
-                    "year" => $this->previousYearPeriod->year,
-                    "link" => route("year-periods.select", $this->previousYearPeriod),
-                ],
-                [
-                    "year" => $this->currentYearPeriod->year,
-                    "link" => route("year-periods.select", $this->currentYearPeriod),
-                ],
-                [
-                    "year" => $this->nextYearPeriod->year,
-                    "link" => route("year-periods.select", $this->nextYearPeriod),
-                ],
-            ],
-        ];
-
-        $this->assertSame($expected, $this->yearPeriodRetriever->links());
-    }
-}