diff --git a/src/Checkpoints/ActivationCheckpoint.php b/src/Checkpoints/ActivationCheckpoint.php
new file mode 100644
index 0000000..b0e8755
--- /dev/null
+++ b/src/Checkpoints/ActivationCheckpoint.php
@@ -0,0 +1,75 @@
+<?php
+/*
+ * Copyright (c) 2024 Focela Technologies. All rights reserved.
+ * Use of this source code is governed by a MIT style
+ * license that can be found in the LICENSE file.
+ */
+
+namespace Focela\Laratrust\Checkpoints;
+
+use Focela\Laratrust\Users\UserInterface;
+use Focela\Laratrust\Activations\ActivationRepositoryInterface;
+
+class ActivationCheckpoint implements CheckpointInterface
+{
+    use AuthenticatedCheckpoint;
+
+    /**
+     * The Activations repository instance.
+     *
+     * @var ActivationRepositoryInterface
+     */
+    protected $activations;
+
+    /**
+     * Constructor.
+     *
+     * @param ActivationRepositoryInterface $activations
+     *
+     * @return void
+     */
+    public function __construct(ActivationRepositoryInterface $activations)
+    {
+        $this->activations = $activations;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function login(UserInterface $user): bool
+    {
+        return $this->checkActivation($user);
+    }
+
+    /**
+     * Checks the activation status of the given user.
+     *
+     * @param UserInterface $user
+     *
+     * @throws NotActivatedException
+     *
+     * @return bool
+     */
+    protected function checkActivation(UserInterface $user): bool
+    {
+        $completed = $this->activations->completed($user);
+
+        if (! $completed) {
+            $exception = new NotActivatedException('Your account has not been activated yet.');
+
+            $exception->setUser($user);
+
+            throw $exception;
+        }
+
+        return true;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function check(UserInterface $user): bool
+    {
+        return $this->checkActivation($user);
+    }
+}
diff --git a/src/Checkpoints/AuthenticatedCheckpoint.php b/src/Checkpoints/AuthenticatedCheckpoint.php
new file mode 100644
index 0000000..3dd1df3
--- /dev/null
+++ b/src/Checkpoints/AuthenticatedCheckpoint.php
@@ -0,0 +1,21 @@
+<?php
+/*
+ * Copyright (c) 2024 Focela Technologies. All rights reserved.
+ * Use of this source code is governed by a MIT style
+ * license that can be found in the LICENSE file.
+ */
+
+namespace Focela\Laratrust\Checkpoints;
+
+use Focela\Laratrust\Users\UserInterface;
+
+trait AuthenticatedCheckpoint
+{
+    /**
+     * @inheritdoc
+     */
+    public function fail(?UserInterface $user = null): bool
+    {
+        return true;
+    }
+}
diff --git a/src/Checkpoints/CheckpointInterface.php b/src/Checkpoints/CheckpointInterface.php
new file mode 100644
index 0000000..905f507
--- /dev/null
+++ b/src/Checkpoints/CheckpointInterface.php
@@ -0,0 +1,42 @@
+<?php
+/*
+ * Copyright (c) 2024 Focela Technologies. All rights reserved.
+ * Use of this source code is governed by a MIT style
+ * license that can be found in the LICENSE file.
+ */
+
+namespace Focela\Laratrust\Checkpoints;
+
+use Focela\Laratrust\Users\UserInterface;
+
+interface CheckpointInterface
+{
+    /**
+     * Checkpoint after a user is logged in. Return false to deny persistence.
+     *
+     * @param UserInterface $user
+     *
+     * @return bool
+     */
+    public function login(UserInterface $user): bool;
+
+    /**
+     * Checkpoint for when a user is currently stored in the session.
+     *
+     * @param UserInterface $user
+     *
+     * @return bool
+     */
+    public function check(UserInterface $user): bool;
+
+    /**
+     * Checkpoint for when a failed login attempt is logged. User is not always
+     * passed and the result of the method will not affect anything, as the
+     * login failed.
+     *
+     * @param UserInterface|null $user
+     *
+     * @return bool
+     */
+    public function fail(?UserInterface $user = null): bool;
+}
diff --git a/src/Checkpoints/NotActivatedException.php b/src/Checkpoints/NotActivatedException.php
new file mode 100644
index 0000000..dec5e87
--- /dev/null
+++ b/src/Checkpoints/NotActivatedException.php
@@ -0,0 +1,42 @@
+<?php
+/*
+ * Copyright (c) 2024 Focela Technologies. All rights reserved.
+ * Use of this source code is governed by a MIT style
+ * license that can be found in the LICENSE file.
+ */
+
+namespace Focela\Laratrust\Checkpoints;
+
+use Focela\Laratrust\Users\UserInterface;
+
+class NotActivatedException extends \RuntimeException
+{
+    /**
+     * The user which caused the exception.
+     *
+     * @var UserInterface
+     */
+    protected $user;
+
+    /**
+     * Returns the user.
+     *
+     * @return UserInterface
+     */
+    public function getUser(): UserInterface
+    {
+        return $this->user;
+    }
+
+    /**
+     * Sets the user associated with Laratrust (does not log in).
+     *
+     * @param UserInterface
+     *
+     * @return void
+     */
+    public function setUser(UserInterface $user): void
+    {
+        $this->user = $user;
+    }
+}
diff --git a/src/Checkpoints/ThrottleCheckpoint.php b/src/Checkpoints/ThrottleCheckpoint.php
new file mode 100644
index 0000000..0d23813
--- /dev/null
+++ b/src/Checkpoints/ThrottleCheckpoint.php
@@ -0,0 +1,148 @@
+<?php
+/*
+ * Copyright (c) 2024 Focela Technologies. All rights reserved.
+ * Use of this source code is governed by a MIT style
+ * license that can be found in the LICENSE file.
+ */
+
+namespace Focela\Laratrust\Checkpoints;
+
+use Focela\Laratrust\Users\UserInterface;
+use Focela\Laratrust\Throttling\ThrottleRepositoryInterface;
+
+class ThrottleCheckpoint implements CheckpointInterface
+{
+    /**
+     * The Throttle repository instance.
+     *
+     * @var ThrottleRepositoryInterface
+     */
+    protected $throttle;
+
+    /**
+     * The cached IP address, used for checkpoints checks.
+     *
+     * @var string
+     */
+    protected $ipAddress;
+
+    /**
+     * Constructor.
+     *
+     * @param ThrottleRepositoryInterface $throttle
+     * @param string                      $ipAddress
+     *
+     * @return void
+     */
+    public function __construct(ThrottleRepositoryInterface $throttle, $ipAddress = null)
+    {
+        $this->throttle = $throttle;
+
+        if (isset($ipAddress)) {
+            $this->ipAddress = $ipAddress;
+        }
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function login(UserInterface $user): bool
+    {
+        return $this->checkThrottling('login', $user);
+    }
+
+    /**
+     * Checks the throttling status of the given user.
+     *
+     * @param string             $action
+     * @param UserInterface|null $user
+     *
+     * @return bool
+     */
+    protected function checkThrottling(string $action, ?UserInterface $user = null): bool
+    {
+        // If we are just checking an existing logged in person, the global delay
+        // shouldn't stop them being logged in at all. Only their IP address and
+        // user a
+        if ($action === 'login') {
+            $globalDelay = $this->throttle->globalDelay();
+
+            if ($globalDelay > 0) {
+                $this->throwException("Too many unsuccessful attempts have been made globally, logins are locked for another [{$globalDelay}] second(s).", 'global', $globalDelay);
+            }
+        }
+
+        // Suspicious activity from a single IP address will not only lock
+        // logins but also any logged in users from that IP address. This
+        // should deter a single hacker who may have guessed a password
+        // within the configured throttling limit.
+        if (isset($this->ipAddress)) {
+            $ipDelay = $this->throttle->ipDelay($this->ipAddress);
+
+            if ($ipDelay > 0) {
+                $this->throwException("Suspicious activity has occured on your IP address and you have been denied access for another [{$ipDelay}] second(s).", 'ip', $ipDelay);
+            }
+        }
+
+        // We will only suspend people logging into a user account. This will
+        // leave the logged in user unaffected. Picture a famous person who's
+        // account is being locked as they're logged in, purely because
+        // others are trying to hack it.
+        if ($action === 'login' && isset($user)) {
+            $userDelay = $this->throttle->userDelay($user);
+
+            if ($userDelay > 0) {
+                $this->throwException("Too many unsuccessful login attempts have been made against your account. Please try again after another [{$userDelay}] second(s).", 'user', $userDelay);
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Throws a throttling exception.
+     *
+     * @param string $message
+     * @param string $type
+     * @param int    $delay
+     *
+     * @throws ThrottlingException
+     *
+     * @return void
+     */
+    protected function throwException(string $message, string $type, int $delay): void
+    {
+        $exception = new ThrottlingException($message);
+
+        $exception->setDelay($delay);
+
+        $exception->setType($type);
+
+        throw $exception;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function check(UserInterface $user): bool
+    {
+        return $this->checkThrottling('check', $user);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function fail(?UserInterface $user = null): bool
+    {
+        // We'll check throttling firstly from any previous attempts. This
+        // will throw the required exceptions if the user has already
+        // tried to login too many times.
+        $this->checkThrottling('login', $user);
+
+        // Now we've checked previous attempts, we'll log this latest attempt.
+        // It'll be picked up the next time if the user tries again.
+        $this->throttle->log($this->ipAddress, $user);
+
+        return true;
+    }
+}
diff --git a/src/Checkpoints/ThrottlingException.php b/src/Checkpoints/ThrottlingException.php
new file mode 100644
index 0000000..8a0ebf9
--- /dev/null
+++ b/src/Checkpoints/ThrottlingException.php
@@ -0,0 +1,85 @@
+<?php
+/*
+ * Copyright (c) 2024 Focela Technologies. All rights reserved.
+ * Use of this source code is governed by a MIT style
+ * license that can be found in the LICENSE file.
+ */
+
+namespace Focela\Laratrust\Checkpoints;
+
+use Carbon\Carbon;
+
+class ThrottlingException extends \RuntimeException
+{
+    /**
+     * The delay, in seconds.
+     *
+     * @var int
+     */
+    protected $delay = 0;
+
+    /**
+     * The throttling type which caused the exception.
+     *
+     * @var string
+     */
+    protected $type = '';
+
+    /**
+     * Returns the delay.
+     *
+     * @return int
+     */
+    public function getDelay(): int
+    {
+        return $this->delay;
+    }
+
+    /**
+     * Sets the delay.
+     *
+     * @param int $delay
+     *
+     * @return $this
+     */
+    public function setDelay(int $delay): self
+    {
+        $this->delay = $delay;
+
+        return $this;
+    }
+
+    /**
+     * Returns the type.
+     *
+     * @return string
+     */
+    public function getType(): string
+    {
+        return $this->type;
+    }
+
+    /**
+     * Sets the type.
+     *
+     * @param string $type
+     *
+     * @return $this
+     */
+    public function setType(string $type): self
+    {
+        $this->type = $type;
+
+        return $this;
+    }
+
+    /**
+     * Returns a Carbon object representing the time which the throttle is lifted.
+     *
+     * @return Carbon
+     */
+    public function getFree(): Carbon
+    {
+        return Carbon::now()->addSeconds($this->delay);
+    }
+}
diff --git a/tests/Checkpoints/ActivationCheckpointTest.php b/tests/Checkpoints/ActivationCheckpointTest.php
new file mode 100644
index 0000000..6d5fda3
--- /dev/null
+++ b/tests/Checkpoints/ActivationCheckpointTest.php
@@ -0,0 +1,100 @@
+<?php
+/*
+ * Copyright (c) 2024 Focela Technologies. All rights reserved.
+ * Use of this source code is governed by a MIT style
+ * license that can be found in the LICENSE file.
+ */
+
+namespace Focela\Laratrust\Tests\Checkpoints;
+
+use Mockery as m;
+use PHPUnit\Framework\TestCase;
+use Focela\Laratrust\Users\EloquentUser;
+use Focela\Laratrust\Checkpoints\ActivationCheckpoint;
+use Focela\Laratrust\Checkpoints\NotActivatedException;
+use Focela\Laratrust\Activations\ActivationRepositoryInterface;
+use Focela\Laratrust\Activations\IlluminateActivationRepository;
+
+class ActivationCheckpointTest extends TestCase
+{
+    /**
+     * The Activations repository instance.
+     *
+     * @var ActivationRepositoryInterface
+     */
+    protected $activations;
+
+    /**
+     * The Eloquent User instance.
+     *
+     * @var EloquentUser
+     */
+    protected $user;
+
+    /**
+     * The activation checkpoint.
+     *
+     * @var \Focela\Laratrust\Checkpoint\ActivationCheckpoint
+     */
+    protected $checkpoint;
+
+    /** @test */
+    public function an_activated_user_can_login()
+    {
+        $this->activations->shouldReceive('completed')->once()->andReturn(true);
+
+        $status = $this->checkpoint->login($this->user);
+
+        $this->assertTrue($status);
+    }
+
+    /** @test */
+    public function an_exception_will_be_thrown_when_authenticating_a_non_activated_user()
+    {
+        $this->activations->shouldReceive('completed')->once()->andReturn(false);
+
+        try {
+            $this->checkpoint->check($this->user);
+        } catch (NotActivatedException $e) {
+            $this->assertInstanceOf(EloquentUser::class, $e->getUser());
+        }
+    }
+
+    /** @test */
+    public function can_return_true_when_fail_is_called()
+    {
+        $this->assertTrue($this->checkpoint->fail());
+    }
+
+    /** @test */
+    public function an_exception_will_be_thrown_when_the_user_is_not_activated_and_determining_if_the_user_is_logged_in()
+    {
+        $this->expectException(NotActivatedException::class);
+
+        $this->activations->shouldReceive('completed')->once();
+
+        $this->checkpoint->check($this->user);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    protected function setUp(): void
+    {
+        $this->activations = m::mock(IlluminateActivationRepository::class);
+        $this->user        = m::mock(EloquentUser::class);
+        $this->checkpoint  = new ActivationCheckpoint($this->activations);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    protected function tearDown(): void
+    {
+        $this->activations = null;
+        $this->user        = null;
+        $this->checkpoint  = null;
+
+        m::close();
+    }
+}
diff --git a/tests/Checkpoints/ThrottleCheckpointTest.php b/tests/Checkpoints/ThrottleCheckpointTest.php
new file mode 100644
index 0000000..1ccb4e9
--- /dev/null
+++ b/tests/Checkpoints/ThrottleCheckpointTest.php
@@ -0,0 +1,164 @@
+<?php
+/*
+ * Copyright (c) 2024 Focela Technologies. All rights reserved.
+ * Use of this source code is governed by a MIT style
+ * license that can be found in the LICENSE file.
+ */
+
+namespace Focela\Laratrust\Tests\Checkpoints;
+
+use Mockery as m;
+use Carbon\Carbon;
+use PHPUnit\Framework\TestCase;
+use Focela\Laratrust\Users\EloquentUser;
+use Focela\Laratrust\Checkpoints\ThrottleCheckpoint;
+use Focela\Laratrust\Checkpoints\ThrottleCheckpoints;
+use Focela\Laratrust\Checkpoints\ThrottlingException;
+use Focela\Laratrust\Throttling\ThrottleRepositoryInterface;
+use Focela\Laratrust\Throttling\IlluminateThrottleRepository;
+
+class ThrottleCheckpointTest extends TestCase
+{
+    /**
+     * The Checkpoint instance.
+     *
+     * @var ThrottleCheckpoints
+     */
+    protected $checkpoint;
+
+    /**
+     * The Eloquent User instance.
+     *
+     * @var EloquentUser
+     */
+    protected $user;
+
+    /**
+     * The Users repository instance.
+     *
+     * @var ThrottleRepositoryInterface
+     */
+    protected $throttle;
+
+    /** @test */
+    public function can_login_the_user_without_being_throttled()
+    {
+        $this->throttle->shouldReceive('globalDelay')->once()->andReturn(0);
+        $this->throttle->shouldReceive('ipDelay')->once();
+        $this->throttle->shouldReceive('userDelay')->once()->andReturn(0);
+
+        $status = $this->checkpoint->login($this->user);
+
+        $this->assertTrue($status);
+    }
+
+    /** @test */
+    public function can_check_if_the_user_is_being_throttled()
+    {
+        $this->throttle->shouldReceive('ipDelay')->once();
+
+        $status = $this->checkpoint->check($this->user);
+
+        $this->assertTrue($status);
+    }
+
+    /** @test */
+    public function can_log_a_throttling_event()
+    {
+        $this->throttle->shouldReceive('globalDelay')->once();
+        $this->throttle->shouldReceive('ipDelay')->once();
+        $this->throttle->shouldReceive('userDelay')->once();
+        $this->throttle->shouldReceive('log')->once();
+
+        $this->checkpoint->fail($this->user);
+
+        $this->assertTrue(true); // TODO: Add proper assertion later
+    }
+
+    /** @test */
+    public function testWithIpAddress()
+    {
+        $this->throttle->shouldReceive('globalDelay')->once();
+        $this->throttle->shouldReceive('ipDelay')->once();
+        $this->throttle->shouldReceive('userDelay')->once();
+        $this->throttle->shouldReceive('log')->once();
+
+        $status = $this->checkpoint->fail($this->user);
+
+        $this->assertTrue(true); // TODO: Add proper assertion later
+    }
+
+    /** @test */
+    public function testFailedLogin()
+    {
+        $this->expectException(ThrottlingException::class);
+        $this->expectExceptionMessage('Too many unsuccessful attempts have been made globally, logins are locked for another [10] second(s).');
+
+        $this->throttle->shouldReceive('globalDelay')->once()->andReturn(10);
+
+        $this->checkpoint->login($this->user);
+    }
+
+    /** @test */
+    public function testThrowsExceptionWithIpDelay()
+    {
+        $this->expectException(ThrottlingException::class);
+        $this->expectExceptionMessage('Suspicious activity has occured on your IP address and you have been denied access for another [10] second(s).');
+
+        $this->throttle->shouldReceive('globalDelay')->once();
+        $this->throttle->shouldReceive('ipDelay')->once()->andReturn(10);
+
+        $this->checkpoint->fail($this->user);
+    }
+
+    /** @test */
+    public function testThrowsExceptionWithUserDelay()
+    {
+        $this->expectException(ThrottlingException::class);
+        $this->expectExceptionMessage('Too many unsuccessful login attempts have been made against your account. Please try again after another [10] second(s).');
+
+        $this->throttle->shouldReceive('globalDelay')->once();
+        $this->throttle->shouldReceive('ipDelay')->once()->andReturn(0);
+        $this->throttle->shouldReceive('userDelay')->once()->andReturn(10);
+
+        $this->checkpoint->fail($this->user);
+    }
+
+    /** @test */
+    public function testGetThrottlingExceptionAttributes()
+    {
+        $this->throttle->shouldReceive('globalDelay')->once();
+        $this->throttle->shouldReceive('ipDelay')->once()->andReturn(0);
+        $this->throttle->shouldReceive('userDelay')->once()->andReturn(10);
+
+        try {
+            $this->checkpoint->fail($this->user);
+        } catch (ThrottlingException $e) {
+            $this->assertSame(10, $e->getDelay());
+            $this->assertSame('user', $e->getType());
+            $this->assertEqualsWithDelta(Carbon::now()->addSeconds(10), $e->getFree(), 3);
+        }
+    }
+
+    /**
+     * @inheritdoc
+     */
+    protected function setUp(): void
+    {
+        $this->throttle   = m::mock(IlluminateThrottleRepository::class);
+        $this->user       = m::mock(EloquentUser::class);
+        $this->checkpoint = new ThrottleCheckpoint($this->throttle, '127.0.0.1');
+    }
+
+    /**
+     * @inheritdoc
+     */
+    protected function tearDown(): void
+    {
+        $this->throttle   = null;
+        $this->user       = null;
+        $this->checkpoint = null;
+
+        m::close();
+    }
+}