diff --git a/api/main_endpoints/routes/LeetCodeLeaderboard.js b/api/main_endpoints/routes/LeetCodeLeaderboard.js
new file mode 100644
index 000000000..e8075dcb0
--- /dev/null
+++ b/api/main_endpoints/routes/LeetCodeLeaderboard.js
@@ -0,0 +1,108 @@
+const express = require('express');
+const router = express.Router();
+const {
+  OK,
+  SERVER_ERROR,
+  BAD_REQUEST
+} = require('../../util/constants.js').STATUS_CODES;
+const { decodeToken } = require('../util/token-functions.js');
+const logger = require('../../util/logger.js');
+const {
+  getAllUsers,
+  addUserToLeaderboard,
+  deleteUserFromLeaderboard,
+  checkIfUserExists,
+} = require('../util/LeetCodeLeaderboard.js');
+const AuditLogActions = require('../util/auditLogActions.js');
+const AuditLog = require('../models/AuditLog.js');
+const membershipState = require('../../util/constants').MEMBERSHIP_STATE;
+
+router.get('/getAllUsers', async (req, res) => {
+  const decoded = await decodeToken(req, membershipState.OFFICER);
+  if (decoded.status !== OK) {
+    return res.sendStatus(decoded.status);
+  }
+
+  const users = await getAllUsers();
+  if (!users) {
+    return res.status(SERVER_ERROR);
+  }
+  return res.status(OK).send({ users });
+});
+
+router.post('/addUser', async (req, res) => {
+  const decoded = await decodeToken(req, membershipState.OFFICER);
+  if (decoded.status !== OK) {
+    return res.sendStatus(decoded.status);
+  }
+
+  const { username, firstName, lastName } = req.body;
+  const required = [
+    { value: username, title: 'LeetCode username', },
+    { value: firstName, title: 'User\'s first name', },
+    { value: lastName, title: 'User\'s last name', }
+  ];
+
+  const missingValue = required.find(({ value }) => !value);
+
+  if (missingValue) {
+    return res.status(BAD_REQUEST).send(`${missingValue.title} missing from request`);
+  }
+
+  if (!await addUserToLeaderboard({
+    username,
+    firstName,
+    lastName
+  })) {
+    return res.sendStatus(SERVER_ERROR);
+  }
+
+  AuditLog.create({
+    userId: decoded.token._id,
+    action: AuditLogActions.ADD_LEETCODE_USER,
+    details: { username },
+  });
+  return res.sendStatus(OK);
+});
+
+router.post('/deleteUser', async (req, res) => {
+  const decoded = await decodeToken(req, membershipState.OFFICER);
+  if (decoded.status !== OK) {
+    return res.sendStatus(decoded.status);
+  }
+
+  const { username } = req.body;
+  if (!username) {
+    return res.status(BAD_REQUEST).send('Username field missing');
+  }
+
+  if (!await deleteUserFromLeaderboard(username)) {
+    return res.sendStatus(SERVER_ERROR);
+  }
+
+  AuditLog.create({
+    userId: decoded.token._id,
+    action: AuditLogActions.DELETE_LEETCODE_USER,
+    details: { username },
+  });
+  return res.sendStatus(OK);
+});
+
+router.post('/checkIfUserExists', async (req, res) => {
+  const decoded = await decodeToken(req, membershipState.OFFICER);
+  if (decoded.status !== OK) {
+    return res.sendStatus(decoded.status);
+  }
+
+  const { username } = req.body;
+  if (!username) {
+    return res.status(BAD_REQUEST).send('Username field missing');
+  }
+  const response = await checkIfUserExists(username);
+  if (response.error) {
+    return res.status(response.status).send(response.message);
+  }
+  return res.status(OK).send(response.exists);
+});
+
+module.exports = router;
diff --git a/api/main_endpoints/util/LeetCodeLeaderboard.js b/api/main_endpoints/util/LeetCodeLeaderboard.js
new file mode 100644
index 000000000..ada93cf7a
--- /dev/null
+++ b/api/main_endpoints/util/LeetCodeLeaderboard.js
@@ -0,0 +1,103 @@
+const logger = require('../../util/logger');
+const LEETCODE_URL = 'http://192.168.69.180:8080';
+
+async function getAllUsers() {
+  try {
+    const url = new URL('/getAllUsers', LEETCODE_URL);
+    const res = await fetch(url.href);
+    const data = await res.json();
+    if ('error' in data) {
+      logger.error('Error from LeetCode Leaderboard: ', data.error);
+      return null;
+    }
+    return data.users;
+  } catch (err) {
+    logger.error('getAllUsers encountered an error: ', err);
+    return null;
+  }
+}
+
+async function addUserToLeaderboard(userData) {
+  try {
+    const url = new URL('/user/add', LEETCODE_URL);
+    const res = await fetch(url.href, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(userData),
+    });
+    const data = await res.json();
+    if ('error' in data) {
+      logger.error('Error from LeetCode Leaderboard: ', data.error);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    logger.error('addUserToLeaderboard encountered an error: ', err);
+    return false;
+  }
+}
+
+async function deleteUserFromLeaderboard(username) {
+  try {
+    const url = new URL('/user/remove', LEETCODE_URL);
+    const res = await fetch(url.href, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ username }),
+    });
+    const data = await res.json();
+    if ('error' in data) {
+      logger.error('Error from LeetCode Leaderboard: ', data.error);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    logger.error('deleteUserFromLeaderboard encountered an error: ', err);
+    return false;
+  }
+}
+
+async function checkIfUserExists(username) {
+  try {
+    const url = new URL('/checkIfUserExists', LEETCODE_URL);
+    const res = await fetch(url.href, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ username }),
+    });
+    const data = await res.json();
+    if ('error' in data) {
+      logger.error('Error from LeetCode Leaderboard: ', data.error);
+      return {
+        error: true,
+        message: data.error,
+        status: data.status_code,
+      };
+    }
+    return {
+      error: false,
+      exists: data.exists,
+    };
+
+  } catch (err) {
+    logger.error('checkIfUserExists encountered an error: ', err);
+    return {
+      error: true,
+      message: err,
+    };
+  }
+}
+
+module.exports = {
+  getAllUsers,
+  addUserToLeaderboard,
+  deleteUserFromLeaderboard,
+  checkIfUserExists,
+};
+
diff --git a/api/main_endpoints/util/auditLogActions.js b/api/main_endpoints/util/auditLogActions.js
index 13e7a3d5b..55d885c06 100644
--- a/api/main_endpoints/util/auditLogActions.js
+++ b/api/main_endpoints/util/auditLogActions.js
@@ -15,6 +15,8 @@ const AuditLogActions = {
   ADD_CARD: 'ADD_CARD',
   DELETE_CARD: 'DELETE_CARD',
   EDIT_CARD: 'EDIT_CARD',
+  ADD_LEETCODE_USER: 'ADD_LEETCODE_USER',
+  DELETE_LEETCODE_USER: 'DELETE_LEETCODE_USER',
 };
 
 module.exports = AuditLogActions;
diff --git a/src/APIFunctions/LeetCodeLeaderboard.js b/src/APIFunctions/LeetCodeLeaderboard.js
new file mode 100644
index 000000000..b666daf1d
--- /dev/null
+++ b/src/APIFunctions/LeetCodeLeaderboard.js
@@ -0,0 +1,100 @@
+import { ApiResponse } from './ApiResponses';
+import { BASE_API_URL } from '../Enums';
+
+export async function getAllUsers(token) {
+  let status = new ApiResponse();
+  try {
+    const url = new URL('/api/LeetCodeLeaderboard/getAllUsers', BASE_API_URL);
+    const res = await fetch(url.href, {
+      headers: {
+        'Authorization': `Bearer ${token}`,
+      }
+    });
+    if (res.ok) {
+      const result = await res.json();
+      status.responseData = result;
+    } else {
+      status.error = true;
+    }
+  } catch (err) {
+    status.error = true;
+    status.responseData = err;
+  }
+  return status;
+}
+
+export async function addUser(userData, token) {
+  let status = new ApiResponse();
+  try {
+    const url = new URL('/api/LeetCodeLeaderboard/addUser', BASE_API_URL);
+    const res = await fetch(url.href, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(userData),
+    });
+    if (res.ok) {
+      const result = await res.json();
+      status.responseData = result;
+    } else {
+      status.error = true;
+    }
+  } catch (err) {
+    status.error = true;
+    status.responseData = err;
+  }
+  return status;
+}
+
+export async function deleteUser(username, token) {
+  let status = new ApiResponse();
+  try {
+    const url = new URL('/api/LeetCodeLeaderboard/deleteUser', BASE_API_URL);
+    const res = await fetch(url.href, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ username }),
+    });
+    if (res.ok) {
+      const result = await res.json();
+      status.responseData = result;
+    } else {
+      status.error = true;
+    }
+  } catch (err) {
+    status.error = true;
+    status.responseData = err;
+  }
+  return status;
+}
+
+export async function checkIfUserExists(username, token) {
+  let status = new ApiResponse();
+  try {
+    const url = new URL('/api/LeetCodeLeaderboard/checkIfUserExists', BASE_API_URL);
+    const res = await fetch(url.href, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+      body: JSON.stringify({ username }),
+    });
+    if (res.ok) {
+      const result = await res.json();
+      status.responseData = result;
+    } else {
+      status.error = true;
+    }
+  } catch (err) {
+    status.error = true;
+    status.responseData = err;
+  }
+  return status;
+}
+
diff --git a/src/Components/Navbar/AdminNavbar.js b/src/Components/Navbar/AdminNavbar.js
index 3221d9eb4..2e74272d1 100644
--- a/src/Components/Navbar/AdminNavbar.js
+++ b/src/Components/Navbar/AdminNavbar.js
@@ -100,6 +100,15 @@ export default function UserNavBar(props) {
         </svg>
       )
     },
+    {
+      title: 'LeetCode Leaderboard',
+      route: '/leetcode-leaderboard',
+      icon: (
+        <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" strokeWidth="1.5" stroke="currentColor" className="size-6">
+          <path strokeLinecap="round" strokeLinejoin="round" d="M8.242 5.992h12m-12 6.003H20.24m-12 5.999h12M4.117 7.495v-3.75H2.99m1.125 3.75H2.99m1.125 0H5.24m-1.92 2.577a1.125 1.125 0 1 1 1.591 1.59l-1.83 1.83h2.16M2.99 15.745h1.125a1.125 1.125 0 0 1 0 2.25H3.74m0-.002h.375a1.125 1.125 0 0 1 0 2.25H2.99" />
+        </svg>
+      ),
+    },
   ];
 
   const renderRoutesForNavbar = (navbarLinks) => {
diff --git a/src/Pages/LeetCodeLeaderboard/LeetCodeLeaderboard.js b/src/Pages/LeetCodeLeaderboard/LeetCodeLeaderboard.js
new file mode 100644
index 000000000..281bd70b8
--- /dev/null
+++ b/src/Pages/LeetCodeLeaderboard/LeetCodeLeaderboard.js
@@ -0,0 +1,226 @@
+import React, { useState, useEffect } from 'react';
+import {
+  getAllUsers,
+  deleteUser,
+  addUser,
+  checkIfUserExists
+} from '../../APIFunctions/LeetCodeLeaderboard.js';
+import { trashcanSymbol } from '../Overview/SVG.js';
+import ConfirmationModal from '../../Components/DecisionModal/ConfirmationModal.js';
+import { useSCE } from '../../Components/context/SceContext.js';
+
+export default function LeetCodeLeaderboard() {
+  const { user } = useSCE();
+  const token = user.token;
+
+  const [registeredUsers, setRegisteredUsers] = useState([]);
+  const [toggleDelete, setToggleDelete] = useState(false);
+  const [userToDelete, setUserToDelete] = useState({});
+  const [firstName, setFirstName] = useState('');
+  const [lastName, setLastName] = useState('');
+  const [leetcodeUsername, setLeetcodeUsername] = useState('');
+  const [confirmLeetcodeUsername, setConfirmLeetcodeUsername] = useState('');
+  const [message, setMessage] = useState('');
+  const [isError, setIsError] = useState(false);
+  const [isDisabled, setIsDisabled] = useState(true);
+
+  async function getAllRegisteredUsers() {
+    const apiResponse = await getAllUsers(token);
+    if (!apiResponse.error) {
+      setRegisteredUsers(apiResponse.responseData.users);
+    }
+  }
+
+  function handleDeleteClick(user) {
+    setToggleDelete(!toggleDelete);
+    setUserToDelete(user);
+  }
+
+  function resetInputFields() {
+    setFirstName('');
+    setLastName('');
+    setLeetcodeUsername('');
+    setConfirmLeetcodeUsername('');
+  }
+
+  async function handleRegisterUser(e) {
+    e.preventDefault();
+    const doesUserExist = await checkIfUserExists(leetcodeUsername, token);
+    if (doesUserExist.responseData) {
+      setMessage('This username is already registered, please try again');
+      return;
+    }
+    const newUser = {
+      username: leetcodeUsername,
+      firstName,
+      lastName
+    };
+    if (!await addUser(newUser, token)) {
+      setMessage('Error registering user, please try again later');
+    } else {
+      getAllRegisteredUsers();
+    }
+    resetInputFields();
+  }
+
+  useEffect(() => {
+    getAllRegisteredUsers();
+  }, []);
+
+  useEffect(() => {
+    setIsError(() => {
+      if (leetcodeUsername.length === 0 || confirmLeetcodeUsername.length === 0) {
+        setMessage('');
+        setIsDisabled(true);
+        return false;
+      }
+      if (leetcodeUsername !== confirmLeetcodeUsername) {
+        setMessage('Usernames do not match.');
+        setIsDisabled(true);
+        return true;
+      }
+      setMessage('');
+      setIsDisabled(false);
+      return false;
+    });
+  }, [leetcodeUsername, confirmLeetcodeUsername]);
+
+  return (
+    <div className='text-center overview-container bg-gray min-h-[100dvh]'>
+      <h1 className='text-gray-700 dark:text-white text-4xl font-bold py-4'>
+        SCE LeetCode Leaderboard
+      </h1>
+      <pre className='text-gray-700 dark:text-white text-lg'>This page manages the functions of the LeetCode Leaderboard</pre>
+      <div className='flex flex-col items-center text-black dark:text-white'>
+        <h1 className='text-gray-700 dark:text-white text-2xl font-bold py-4'>
+          LeetCode Leaderboard
+        </h1>
+        <ConfirmationModal {... {
+          headerText: `Remove ${userToDelete.username}?`,
+          bodyText: `Are you sure you want to remove ${userToDelete.firstName} ${userToDelete.lastName} from the leaderboard? 
+          They'll be gone forever if you do.`,
+          confirmText: `Yes, remove ${userToDelete.username}`,
+          cancelText: 'No, they\'re chill',
+          confirmClassAddons: 'bg-red-600 hover:bg-red-500',
+          handleConfirmation: async () => {
+            await deleteUser(userToDelete.username, token);
+            await getAllRegisteredUsers();
+            setToggleDelete(!toggleDelete);
+          },
+          handleCancel: () => setToggleDelete(!toggleDelete),
+          open: toggleDelete
+        }
+        } />
+        <div className='max-w-full flex flex-col justify-center items-center'>
+          <div className='max-w-[1150px] max-h-[1150px] overflow-hidden inline-block scale-50 origin-top border-[6px] border-red-500 dark:border-white' style={{ marginBottom: '-500px' }}>
+            <iframe
+              id='led-frame'
+              src='http://192.168.69.180:8888'
+              title='LED Emulator'
+              className='w-[1150px] h-[1150px]'
+              scrolling='no'
+            />
+          </div>
+        </div>
+        <div className='w-full px-8'>
+          <h3 className='text-gray-700 dark:text-white text-lg font-bold'>Registered Users</h3>
+          <div className='flex flex-col'>
+            <div className='my-6'>
+              <span className='label-text text-md'>Enter a user's details here to register them for the LeetCode Leaderboard!</span>
+              <form onSubmit={handleRegisterUser}>
+                <div className='flex flex-row items-center pt-6 pb-4 space-x-2'>
+                  <input
+                    type='text'
+                    placeholder='First name'
+                    value={firstName}
+                    onChange={(e) => setFirstName(e.target.value)}
+                    className='flex-1 text-sm input input-bordered sm:text-base'
+                  />
+                  <input
+                    type='text'
+                    placeholder='Last name'
+                    value={lastName}
+                    onChange={(e) => setLastName(e.target.value)}
+                    className='flex-1 text-sm input input-bordered sm:text-base'
+                  />
+                  <input
+                    type='text'
+                    placeholder='LeetCode username'
+                    value={leetcodeUsername}
+                    onChange={(e) => setLeetcodeUsername(e.target.value)}
+                    className='flex-1 text-sm input input-bordered sm:text-base'
+                  />
+                  <input
+                    type='text'
+                    placeholder='Confirm username'
+                    value={confirmLeetcodeUsername}
+                    onChange={(e) => setConfirmLeetcodeUsername(e.target.value)}
+                    className='flex-1 text-sm input input-bordered sm:text-base'
+                  />
+                  <button
+                    className={`text-sm btn btn-primary sm:text-base hover:text-white flex-grow-0 ${isDisabled ? 'cursor-not-allowed pointer-events-none bg-gray-400' : ''}`}
+                    type='submit'
+                  >
+                    Register
+                  </button>
+                </div>
+                <div className='pb-4'>
+                  <p className={`text-sm min-h-[1.25rem] ${isError ? '' : 'text-red-500'}`}>{message}</p>
+                </div>
+              </form>
+            </div>
+            <div className='overflow-x-auto overflow-y-auto mb-12'>
+              <table className='w-full min-w-full text-gray-700 dark:text-gray-400 table-auto border-collapse'>
+                <thead className='text-xs text-gray-700 uppercase bg-gray-50 dark:bg-gray-700 dark:text-gray-400'>
+                  <tr>
+                    {[
+                      { title: 'First Name', id: 'fn' },
+                      { title: 'Last Name', id: 'ln' },
+                      { title: 'LeetCode Username', id: 'lcu' },
+                      { title: '', id: 'del' }
+                    ].map(({ title, id }) => (
+                      <th key={id} className='px-6 py-3 whitespace-nowrap'>
+                        <div className='flex items-center justify-center'>
+                          {title}
+                        </div>
+                      </th>
+                    ))}
+                  </tr>
+                </thead>
+                <tbody className='text-center text-sm'>
+                  {registeredUsers.map((user, index) => (
+                    <tr key={index} className='bg-white border-b dark:bg-gray-800 dark:border-gray-700'>
+                      <td className='px-6 py-4 font-medium text-gray-700 whitespace-nowrap dark:text-white'>
+                        <div className='h-[2rem] leading-[2rem] px-2 border border-transparent rounded-md'>
+                          {user.firstName}
+                        </div>
+                      </td>
+                      <td className='px-6 py-4 font-medium text-gray-700 whitespace-nowrap dark:text-white'>
+                        <div className='h-[2rem] leading-[2rem] px-2 border border-transparent rounded-md'>
+                          {user.lastName}
+                        </div>
+                      </td>
+                      <td className='px-6 py-4 font-medium text-gray-700 whitespace-nowrap dark:text-white'>
+                        <div className='h-[2rem] leading-[2rem] px-2 border border-transparent rounded-md'>
+                          {user.username}
+                        </div>
+                      </td>
+                      <td>
+                        <button
+                          className='p-2 hover:bg-gray-200 dark:hover:bg-white/30 rounded-xl cursor-pointer'
+                          onClick={() => handleDeleteClick(user)}
+                        >
+                          {trashcanSymbol('#e64539')}
+                        </button>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/Routes.js b/src/Routes.js
index 379435419..460daae28 100644
--- a/src/Routes.js
+++ b/src/Routes.js
@@ -18,6 +18,7 @@ import Messaging from './Pages/Messaging/Messaging.js';
 import Home from './Pages/Home/Home.js';
 import CardReader from './Pages/CardReader/CardReader.js';
 import AuditLogsPage from './Pages/AuditLog/AuditLog.js';
+import LeetCodeLeaderboard from './Pages/LeetCodeLeaderboard/LeetCodeLeaderboard.js';
 
 // Declare an enum for permission check
 export const allowedIf = {
@@ -158,6 +159,14 @@ export const officerOrAdminRoutes = [
     redirect: '/',
     inAdminNavbar: true
   },
+  {
+    Component: LeetCodeLeaderboard,
+    path: '/leetcode-leaderboard',
+    pageName: 'LeetCode Leaderboard',
+    allowedIf: allowedIf.OFFICER_OR_ADMIN,
+    redirect: '/login',
+    inAdminNavbar: true
+  },
   ...memberRoutes,
 ];
 
diff --git a/test/api/LeetCodeLeaderboard.js b/test/api/LeetCodeLeaderboard.js
new file mode 100644
index 000000000..a487ad99a
--- /dev/null
+++ b/test/api/LeetCodeLeaderboard.js
@@ -0,0 +1,264 @@
+/* global describe it before after beforeEach afterEach */
+process.env.NODE_ENV = 'test';
+
+// Require the dev-dependencies
+const chai = require('chai');
+const mongoose = require('mongoose');
+
+const chaiHttp = require('chai-http');
+const {
+  OK,
+  BAD_REQUEST,
+  UNAUTHORIZED,
+  NOT_FOUND,
+  SERVER_ERROR,
+  FORBIDDEN,
+} = require('../../api/util/constants').STATUS_CODES;
+const {
+  initializeTokenMock,
+  setTokenStatus,
+  resetTokenMock,
+  restoreTokenMock,
+} = require('../util/mocks/TokenValidFunctions');
+const sinon = require('sinon');
+const SceApiTester = require('../util/tools/SceApiTester');
+const LeetCodeLeaderboardUtils = require('../../api/main_endpoints/util/LeetCodeLeaderboard');
+
+let app = null;
+let test = null;
+
+const expect = chai.expect;
+const tools = require('../util/tools/tools.js');
+let sandbox = sinon.createSandbox();
+
+chai.should();
+chai.use(chaiHttp);
+
+const token = '';
+
+describe('LeetCodeLeaderboard', () => {
+  let getAllUsersStub = null;
+  let addUserStub = null;
+  let deleteUserStub = null;
+  let checkIfUserExistsStub = null;
+
+  const ADD_API_PATH = '/api/LeetCodeLeaderboard/addUser';
+  const DELETE_API_PATH = '/api/LeetCodeLeaderboard/deleteUser';
+  const GET_ALL_USERS_API_PATH = '/api/LeetCodeLeaderboard/getAllUsers';
+  const CHECK_USER_EXISTS_API_PATH = '/api/LeetCodeLeaderboard/checkIfUserExists';
+
+  before(() => {
+    initializeTokenMock();
+
+    getAllUsersStub = sandbox.stub(LeetCodeLeaderboardUtils, 'getAllUsers');
+    getAllUsersStub.resolves([{ username: 'testuser', firstName: 'Test', lastName: 'User' }]);
+
+    addUserStub = sandbox.stub(LeetCodeLeaderboardUtils, 'addUserToLeaderboard');
+    addUserStub.resolves(true);
+
+    deleteUserStub = sandbox.stub(LeetCodeLeaderboardUtils, 'deleteUserFromLeaderboard');
+    deleteUserStub.resolves(true);
+
+    checkIfUserExistsStub = sandbox.stub(LeetCodeLeaderboardUtils, 'checkIfUserExists');
+    checkIfUserExistsStub.resolves({ exists: true });
+
+    app = tools.initializeServer([
+      __dirname + '/../../api/main_endpoints/routes/LeetCodeLeaderboard.js',
+    ]);
+    test = new SceApiTester(app);
+  });
+
+  beforeEach(() => {
+    setTokenStatus(false);
+  });
+
+  afterEach(() => {
+    resetTokenMock();
+  });
+
+  after(done => {
+    restoreTokenMock();
+    tools.terminateServer(done);
+  });
+
+  describe('GET /getAllUsers', () => {
+    it('Should return 401 when token is not sent', async () => {
+      const result = await test.sendGetRequest(GET_ALL_USERS_API_PATH);
+      expect(result).to.have.status(UNAUTHORIZED);
+    });
+
+    it('Should return 403 when invalid token is sent', async () => {
+      setTokenStatus(null);
+      const result = await test.sendGetRequestWithToken(token,
+        GET_ALL_USERS_API_PATH);
+      expect(result).to.have.status(FORBIDDEN);
+    });
+
+    it('Should return 200 with a successful fetch of all users', async () => {
+      setTokenStatus(true);
+      const result = await test.sendGetRequestWithToken(token,
+        GET_ALL_USERS_API_PATH,
+      );
+      expect(result).to.have.status(OK);
+    });
+
+    it('Should return 500 if there was an error fetching all users', async () => {
+      setTokenStatus(true);
+      getAllUsersStub.resolves(null);
+      const result = await test.sendGetRequestWithToken(token,
+        GET_ALL_USERS_API_PATH,
+      );
+      expect(result).to.have.status(SERVER_ERROR);
+      getAllUsersStub.restore();
+    });
+  });
+
+  describe('POST /addUser', () => {
+    it('Should return 401 when token is not sent', async () => {
+      const result = await test.sendPostRequest(ADD_API_PATH);
+      expect(result).to.have.status(UNAUTHORIZED);
+    });
+
+    it('Should return 403 when invalid token is sent', async () => {
+      setTokenStatus(null);
+      const result = await test.sendPostRequestWithToken(token,
+        ADD_API_PATH);
+      expect(result).to.have.status(FORBIDDEN);
+    });
+
+    it('Should return 400 when required fields are missing', async () => {
+      setTokenStatus(true);
+      const result = await test.sendPostRequestWithToken(token,
+        ADD_API_PATH,
+        { username: 'testuser' },
+      );
+      expect(result).to.have.status(BAD_REQUEST);
+    });
+
+    it('Should return 200 when user is added successfully', async () => {
+      setTokenStatus(true);
+      const result = await test.sendPostRequestWithToken(token,
+        ADD_API_PATH,
+        {
+          username: 'testuser',
+          firstName: 'Test',
+          lastName: 'User',
+        },
+      );
+      expect(result).to.have.status(OK);
+    });
+
+    it('Should return 500 if there was an error adding the user', async () => {
+      setTokenStatus(true);
+      addUserStub.resolves(false);
+      const result = await test.sendPostRequestWithToken(token,
+        ADD_API_PATH,
+        {
+          username: 'testuser',
+          firstName: 'Test',
+          lastName: 'User',
+        },
+      );
+      expect(result).to.have.status(SERVER_ERROR);
+      addUserStub.restore();
+    });
+  });
+
+  describe('POST /deleteUser', () => {
+    it('Should return 401 when token is not sent', async () => {
+      const result = await test.sendPostRequest(DELETE_API_PATH);
+      expect(result).to.have.status(UNAUTHORIZED);
+    });
+
+    it('Should return 403 when invalid token is sent', async () => {
+      setTokenStatus(null);
+      const result = await test.sendPostRequestWithToken(token,
+        DELETE_API_PATH);
+      expect(result).to.have.status(FORBIDDEN);
+    });
+
+    it('Should return 400 when username field is missing', async () => {
+      setTokenStatus(true);
+      const result = await test.sendPostRequestWithToken(token,
+        DELETE_API_PATH,
+        {},
+      );
+      expect(result).to.have.status(BAD_REQUEST);
+    });
+
+    it('Should return 200 when user is deleted successfully', async () => {
+      setTokenStatus(true);
+      const result = await test.sendPostRequestWithToken(token,
+        DELETE_API_PATH,
+        { username: 'testuser' },
+      );
+      expect(result).to.have.status(OK);
+    });
+
+    it('Should return 500 if there was an error deleting the user', async () => {
+      setTokenStatus(true);
+      deleteUserStub.resolves(false);
+      const result = await test.sendPostRequestWithToken(token,
+        DELETE_API_PATH,
+        { username: 'testuser' },
+      );
+      expect(result).to.have.status(SERVER_ERROR);
+      deleteUserStub.restore();
+    });
+  });
+
+  describe('POST /checkIfUserExists', () => {
+    it('Should return 401 when token is not sent', async () => {
+      const result = await test.sendPostRequest(CHECK_USER_EXISTS_API_PATH);
+      expect(result).to.have.status(UNAUTHORIZED);
+    });
+
+    it('Should return 403 when invalid token is sent', async () => {
+      setTokenStatus(null);
+      const result = await test.sendPostRequestWithToken(token,
+        CHECK_USER_EXISTS_API_PATH);
+      expect(result).to.have.status(FORBIDDEN);
+    });
+
+    it('Should return 400 when username field is missing', async () => {
+      setTokenStatus(true);
+      const result = await test.sendPostRequestWithToken(token,
+        CHECK_USER_EXISTS_API_PATH,
+        {},
+      );
+      expect(result).to.have.status(BAD_REQUEST);
+    });
+
+    it('Should return 200 when user existence is checked successfully', async () => {
+      setTokenStatus(true);
+      const result = await test.sendPostRequestWithToken(token,
+        CHECK_USER_EXISTS_API_PATH,
+        { username: 'testuser' },
+      );
+      expect(result).to.have.status(OK);
+    });
+
+    it('Should return 200 and false when user does not exist', async () => {
+      setTokenStatus(true);
+      checkIfUserExistsStub.resolves({ exists: false });
+      const result = await test.sendPostRequestWithToken(token,
+        CHECK_USER_EXISTS_API_PATH,
+        { username: 'nonexistentuser' },
+      );
+      expect(result).to.have.status(OK);
+      expect(result.body).to.equal(false);
+      checkIfUserExistsStub.restore();
+    });
+
+    it('Should return 500 if there was an error checking user existence', async () => {
+      setTokenStatus(true);
+      checkIfUserExistsStub.resolves({ error: true, message: 'Internal server error', status: SERVER_ERROR });
+      const result = await test.sendPostRequestWithToken(token,
+        CHECK_USER_EXISTS_API_PATH,
+        { username: 'testuser' },
+      );
+      expect(result).to.have.status(SERVER_ERROR);
+      checkIfUserExistsStub.restore();
+    });
+  });
+});