diff --git a/commands/apply.js b/commands/apply.js
new file mode 100644
index 0000000..625283c
--- /dev/null
+++ b/commands/apply.js
@@ -0,0 +1,223 @@
+import { EmbedBuilder, SlashCommandBuilder } from 'discord.js';
+import { confirmActionDm } from './utils/confirmActionDm.js';
+import { Logger } from '../utils/index.js';
+import {
+  applicationStartedDmEmbed,
+  closedDmEmbed,
+} from './utils/apply/embeds.js';
+import {
+  submitAnswer,
+  createApplicationSubmission,
+  getApplicationQuestions,
+  submitApplicationSubmission,
+  getApplicationById,
+} from './utils/apply/requests.js';
+import { apiFetch } from '../utils/apiFetch.js';
+
+export const data = new SlashCommandBuilder()
+  .setName('apply')
+  .setDescription('Start an application process')
+  .addStringOption((option) =>
+    option
+      .setName('application')
+      .setDescription('Application name')
+      .setRequired(true)
+      .setAutocomplete(true)
+  );
+
+export const autocomplete = async (interaction) => {
+  const inputValue = interaction.options.getFocused();
+
+  const response = await apiFetch('/application', {
+    method: 'GET',
+    query: {
+      'filter[name]': inputValue,
+    },
+  });
+  const applicationResponse = await response.json();
+  await interaction.respond(
+    applicationResponse.data.map((application) => ({
+      name: application.name,
+      value: `${application.id}`,
+    }))
+  );
+};
+
+export const execute = async (interaction) => {
+  const member = interaction.member;
+  const applicationId = interaction.options.getString('application');
+  const application = await getApplicationById(applicationId);
+  if (!application) {
+    await interaction.reply({
+      content:
+        'The application was not found. Please use the autocomplete. If this issue pressists contact the staff team.',
+      ephemeral: true,
+    });
+    return;
+  }
+
+  for (const restrictedRole of application.restricted_roles) {
+    if (member.roles.cache.has(restrictedRole.role_id)) {
+      await interaction.reply({
+        content: 'You do not have the permission to execute that command.',
+        ephemeral: true,
+      });
+      return;
+    }
+  }
+
+  const channel = await member.createDM();
+  let originalMessage = null;
+  try {
+    originalMessage = await channel.send(
+      'Thank you for starting an application process'
+    );
+  } catch (e) {
+    Logger.error('cannot send direct message: ' + e);
+    await interaction.reply({
+      embeds: [closedDmEmbed],
+      ephemeral: true,
+    });
+    return;
+  }
+  try {
+    await interaction.reply({
+      embeds: [applicationStartedDmEmbed],
+      ephemeral: true,
+    });
+
+    const confirmed = await confirmActionDm(
+      channel,
+      application.confirmation_message,
+      'Yes',
+      `Thank you for applying.\nYour application process for \`${application.name}\` has started.`,
+      originalMessage
+    );
+
+    if (!confirmed) {
+      await channel.send('Application process cancelled');
+      return;
+    }
+
+    const applicationSubmission = await createApplicationSubmission(
+      application.id,
+      member.id
+    );
+    const questions = await getApplicationQuestions(application.id);
+
+    const answerList = [];
+    for (let i = 0; i < questions.length; i++) {
+      const answer = await handleQuestionAnswer(
+        application,
+        channel,
+        questions[i],
+        applicationSubmission.id,
+        i,
+        questions.length
+      );
+      if (answer == null) {
+        return;
+      }
+      answerList.push({ question: questions[i].question, answer });
+    }
+
+    await submitApplicationSubmission(applicationSubmission.id);
+
+    const embed = new EmbedBuilder()
+      .setTitle(`Application for \`${application.name}\` completed`)
+      .setDescription(application.completion_message)
+      .setColor('#f0833a');
+    channel.send({
+      embeds: [embed],
+    });
+  } catch (error) {
+    let message =
+      'An error occurred during the application process. Please try again later or contact the staff team.';
+    let logError = true;
+    if (error.message === 'Application was cancelled.') {
+      message =
+        'Your prevoius application was cancelled in favor for your new application';
+      logError = false;
+    }
+    await handleError(
+      channel,
+      message,
+      `Application error: ${error.message}`,
+      logError
+    );
+  }
+};
+
+const handleQuestionAnswer = async (
+  application,
+  channel,
+  question,
+  applicationSubmissionId,
+  questionNr,
+  questionsLength
+) => {
+  const embed = new EmbedBuilder()
+    .setTitle(
+      `Application for \`${application.name}\` question ${questionNr + 1}/${questionsLength}`
+    )
+    .setDescription(question.question)
+    .setColor('#ffdbe5');
+
+  await channel.send({
+    embeds: [embed],
+  });
+  const collected = await channel.awaitMessages({
+    max: 1,
+    filter: (message) => {
+      return (
+        !message.author.bot && (message.content || message.attachments.size)
+      );
+    },
+    time: 600_000,
+  });
+
+  if (collected.size === 0) {
+    const embed = new EmbedBuilder()
+      .setTitle(`Application timeout`)
+      .setDescription(
+        'You did not provide an answer within the time limit. The application process has been cancelled.'
+      )
+      .setColor('#ce361e');
+    await channel.send({
+      embeds: [embed],
+    });
+    return null;
+  }
+
+  let answer = collected.first().content;
+  if (answer.length != 0) {
+    answer += ' ';
+  }
+  let attachments = '';
+  collected.first().attachments.forEach((attachment) => {
+    attachments += attachment.url + ' ';
+  });
+
+  answer += attachments;
+
+  await submitAnswer(applicationSubmissionId, question.id, answer, attachments);
+  return answer;
+};
+
+const handleError = async (
+  channel,
+  errorMessage,
+  logMessage,
+  logError = true
+) => {
+  const embed = new EmbedBuilder()
+    .setTitle(`Error`)
+    .setDescription(errorMessage)
+    .setColor('#ce361e');
+  await channel.send({
+    embeds: [embed],
+  });
+  if (logError) {
+    Logger.error(logMessage);
+  }
+};
diff --git a/commands/utils/apply/embeds.js b/commands/utils/apply/embeds.js
new file mode 100644
index 0000000..4bfecb1
--- /dev/null
+++ b/commands/utils/apply/embeds.js
@@ -0,0 +1,94 @@
+import { EmbedBuilder } from 'discord.js';
+import { chunkText } from '../utils/chunkText.js';
+import dayjs from 'dayjs';
+
+export const closedDmEmbed = new EmbedBuilder()
+  .setTitle('Error sending DM')
+  .setColor('#ce361e')
+  .setDescription(
+    'I was unable to send you a DM. Please make sure your DMs are open and try again.\n' +
+      "If you don't know how, [click here](https://support.discord.com/hc/en-us/articles/217916488-Blocking-Privacy-Settings)"
+  );
+
+export const applicationStartedDmEmbed = new EmbedBuilder()
+  .setTitle('Application Started')
+  .setColor('#2e856e')
+  .setDescription(
+    'Your application process has been started. Please check your DMs for further instructions.'
+  );
+
+export const getApplicationEmbed = (
+  application,
+  answers,
+  member,
+  applicationStartTime,
+  applicationCount
+) => {
+  const embed = new EmbedBuilder()
+    .setTitle(`${member.displayName}'s application for ${application.name}`)
+    .setThumbnail(member.user.displayAvatarURL())
+    .setTimestamp()
+    .setColor('Yellow');
+
+  let stats;
+  try {
+    // Add stats
+    const now = dayjs();
+    const applicationDuration = now.diff(applicationStartTime, 'seconds');
+    const minutes = Math.floor(applicationDuration / 60);
+    const seconds = applicationDuration % 60;
+    const timeOnServer = dayjs(member.joinedAt).unix();
+
+    stats =
+      `**User ID:** ${member.id}\n` +
+      `**Username:** ${member.user.username}\n` +
+      `**User Mention:** ${member.toString()}\n` +
+      `**Application Duration:** ${minutes} minutes ${seconds} seconds\n` +
+      `**Time on Server:** <t:${timeOnServer}:R>\n` +
+      `**Application Number:** ${applicationCount}`;
+
+    let embedLength = stats.length;
+    answers.forEach((answer) => {
+      const question = answer.question;
+      const answerChunks = chunkText(answer.answer);
+
+      embed.addFields({
+        name: '**' + question + '**',
+        value: answerChunks[0],
+      });
+      embedLength += answerChunks[0].length;
+      for (let i = 1; i < answerChunks.length; i++) {
+        embed.addFields({
+          name: '\u200B', // zero-width space
+          value: answerChunks[i],
+        });
+        embedLength += answerChunks[i].length;
+      }
+
+      if (embedLength > 5000) {
+        throw new Error('Invalid number value');
+      }
+    });
+
+    embed.addFields({
+      name: '**Application Stats**',
+      value: stats,
+    });
+  } catch (e) {
+    if (e.message == 'Invalid number value') {
+      // Logger.debug(e);
+      embed.setFields({
+        name: '**Application too long**',
+        value: 'Please view the application on the panel',
+      });
+      embed.addFields({
+        name: '**Application Stats**',
+        value: stats,
+      });
+    } else {
+      throw e;
+    }
+  }
+
+  return embed;
+};
diff --git a/commands/utils/apply/requests.js b/commands/utils/apply/requests.js
new file mode 100644
index 0000000..6111b1d
--- /dev/null
+++ b/commands/utils/apply/requests.js
@@ -0,0 +1,158 @@
+import { apiFetch } from '../utils/apiFetch.js';
+import dayjs from 'dayjs';
+
+export const getApplicationById = async (applicationId) => {
+  const response = await apiFetch('/application', {
+    method: 'GET',
+    query: {
+      'filter[id]': applicationId,
+      include: 'restrictedRoles',
+    },
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to retrieve application questions: ${await response.text()}`
+    );
+  }
+  return (await response.json()).data[0];
+};
+
+export const createApplicationSubmission = async (applicationId, discordId) => {
+  const response = await apiFetch('/application-submission', {
+    method: 'POST',
+    body: {
+      application_id: applicationId,
+      discord_id: discordId,
+      state: 0,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to create application submission: ${await response.text()}`
+    );
+  }
+
+  return (await response.json()).data;
+};
+
+export const getApplicationQuestions = async (applicationId) => {
+  const response = await apiFetch('/application-question', {
+    method: 'GET',
+    query: {
+      'filter[application_id]': applicationId,
+      'filter[is_active]': true,
+    },
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to retrieve application questions: ${await response.text()}`
+    );
+  }
+  return (await response.json()).data;
+};
+
+export const submitAnswer = async (
+  applicationSubmissionid,
+  questionId,
+  answer,
+  attachments
+) => {
+  const response = await apiFetch('/application-question-answer', {
+    method: 'POST',
+    body: {
+      application_submission_id: applicationSubmissionid,
+      application_question_id: questionId,
+      answer,
+      attachments,
+    },
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    if (error.message === 'Application was cancelled.') {
+      throw new Error(error.message);
+    }
+    throw new Error(`Failed to submit answer: ${await response.text()}`);
+  }
+};
+
+export const submitApplicationSubmission = async (applicationSubmissionid) => {
+  const response = await apiFetch(
+    `/application-submission/${applicationSubmissionid}`,
+    {
+      method: 'PUT',
+      body: {
+        state: 1,
+        submitted_at: dayjs().format('YYYY-MM-DD HH:mm:ss'),
+      },
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to submit application: ${await response.text()}`);
+  }
+};
+
+export const acceptApplicationSubmission = async (
+  applicationSubmissionid,
+  userId,
+  templateId = null,
+  reason = null
+) => {
+  const response = await apiFetch(
+    `/application-submission/${applicationSubmissionid}`,
+    {
+      method: 'PUT',
+      body: {
+        state: 2,
+        handled_by: userId,
+        application_response_id: templateId,
+        custom_response: reason,
+      },
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to accept application: ${await response.text()}`);
+  }
+};
+
+export const denyApplicationSubmission = async (
+  applicationSubmissionid,
+  userId,
+  templateId = null,
+  reason = null
+) => {
+  const response = await apiFetch(
+    `/application-submission/${applicationSubmissionid}`,
+    {
+      method: 'PUT',
+      body: {
+        state: 3,
+        handled_by: userId,
+        application_response_id: templateId,
+        custom_response: reason,
+      },
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to deny application: ${await response.text()}`);
+  }
+};
+
+export const getAllApplicationSubmissions = async (
+  applicationId,
+  discordId
+) => {
+  const response = await apiFetch('/application-submission', {
+    method: 'GET',
+    query: {
+      'filter[application_id]': applicationId,
+      'filter[discord_id]': discordId,
+    },
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to retrieve users applications: ${await response.text()}`
+    );
+  }
+  return (await response.json()).data;
+};
diff --git a/commands/utils/confirmActionDm.js b/commands/utils/confirmActionDm.js
new file mode 100644
index 0000000..3c19226
--- /dev/null
+++ b/commands/utils/confirmActionDm.js
@@ -0,0 +1,72 @@
+import {
+  ButtonBuilder,
+  ButtonStyle,
+  ActionRowBuilder,
+  EmbedBuilder,
+} from 'discord.js';
+
+export const confirmActionDm = async (
+  channel,
+  confirmMessage,
+  confirmLabel,
+  confirmationMessage,
+  originalMessage = null
+) => {
+  const confirm = new ButtonBuilder()
+    .setCustomId('confirm')
+    .setLabel(confirmLabel)
+    .setStyle(ButtonStyle.Success);
+
+  const cancel = new ButtonBuilder()
+    .setCustomId('cancel')
+    .setLabel('Cancel')
+    .setStyle(ButtonStyle.Secondary);
+
+  const row = new ActionRowBuilder().addComponents(confirm, cancel);
+
+  const embed = new EmbedBuilder()
+    .setTitle(`Your Application`)
+    .setDescription(confirmMessage)
+    .setColor('#f0833a');
+
+  const data = {
+    content: '',
+    embeds: [embed],
+    components: [row],
+  };
+  let response = null;
+  if (originalMessage) {
+    response = await originalMessage.edit(data);
+  } else {
+    response = await channel.send(data);
+  }
+
+  let confirmation;
+  try {
+    confirmation = await response.awaitMessageComponent({
+      time: 60_000,
+    });
+
+    if (confirmation.customId === 'confirm') {
+      embed.setDescription(confirmationMessage);
+      await confirmation.update({
+        embeds: [embed],
+        components: [],
+      });
+      return true;
+    } else if (confirmation.customId === 'cancel') {
+      embed.setDescription('Action cancelled');
+      await confirmation.update({
+        embeds: [embed],
+        components: [],
+      });
+      return false;
+    }
+  } catch {
+    await response.edit({
+      content: 'Confirmation not received within 1 minute, cancelling',
+      components: [],
+    });
+    return false;
+  }
+};
diff --git a/events/application.js b/events/application.js
new file mode 100644
index 0000000..16cbc28
--- /dev/null
+++ b/events/application.js
@@ -0,0 +1,145 @@
+import {
+  ModalBuilder,
+  TextInputBuilder,
+  ActionRowBuilder,
+  TextInputStyle,
+} from 'discord.js';
+import {
+  acceptApplicationSubmission,
+  denyApplicationSubmission,
+} from '../commands/applyRequests.js';
+
+export const applicationHandler = async (interaction) => {
+  if (interaction.isModalSubmit()) {
+    handleModal(interaction);
+  }
+  if (interaction.isButton()) {
+    handleButtons(interaction);
+  }
+  if (interaction.isStringSelectMenu()) {
+    handleSelectMenu(interaction);
+  }
+};
+
+const handleModal = async (interaction) => {
+  const match = interaction.customId.match(
+    /^applicationSubmission-([^-]+)-([0-9]+)$/
+  );
+  if (!match) {
+    return;
+  }
+  const action = match[1]; // action
+  const id = match[2]; // id
+  const reason = interaction.fields.getTextInputValue('reason');
+
+  if (action === 'acceptWithReason') {
+    await interaction.reply({
+      content: 'Accepting application',
+      ephemeral: true,
+    });
+    acceptApplicationSubmission(id, interaction.user.id, null, reason);
+  }
+
+  if (action === 'denyWithReason') {
+    await interaction.reply({
+      content: 'Denying application',
+      ephemeral: true,
+    });
+    denyApplicationSubmission(id, interaction.user.id, null, reason);
+  }
+};
+
+const handleButtons = async (interaction) => {
+  const match = interaction.customId.match(
+    /^applicationSubmission-([^-]+)-([0-9]+)$/
+  );
+  if (!match) {
+    return;
+  }
+  const action = match[1]; // action
+  const id = match[2]; // id
+
+  if (action === 'accept') {
+    await interaction.reply({
+      content: 'Accepting application',
+      ephemeral: true,
+    });
+    acceptApplicationSubmission(id, interaction.user.id);
+  }
+
+  if (action === 'deny') {
+    await interaction.reply({
+      content: 'Denying application',
+      ephemeral: true,
+    });
+    denyApplicationSubmission(id, interaction.user.id);
+  }
+
+  if (action === 'acceptWithReason') {
+    const modal = new ModalBuilder()
+      .setCustomId(`applicationSubmission-acceptWithReason-${id}`)
+      .setTitle('Accept application with reason');
+
+    const reasonInput = new TextInputBuilder()
+      .setCustomId('reason')
+      .setLabel('Reason:')
+      .setStyle(TextInputStyle.Paragraph);
+
+    const answerActionRow = new ActionRowBuilder().addComponents(reasonInput);
+
+    modal.addComponents(answerActionRow);
+    await interaction.showModal(modal);
+  }
+
+  if (action === 'denyWithReason') {
+    const modal = new ModalBuilder()
+      .setCustomId(`applicationSubmission-denyWithReason-${id}`)
+      .setTitle('Deny application with reason');
+
+    const reasonInput = new TextInputBuilder()
+      .setCustomId('reason')
+      .setLabel('Reason:')
+      .setStyle(TextInputStyle.Paragraph);
+
+    const answerActionRow = new ActionRowBuilder().addComponents(reasonInput);
+
+    modal.addComponents(answerActionRow);
+    await interaction.showModal(modal);
+  }
+};
+
+const handleSelectMenu = async (interaction) => {
+  const match = interaction.customId.match(
+    /^applicationSubmission-([^-]+)-([0-9]+)$/
+  );
+  if (!match) {
+    return;
+  }
+  const action = match[1]; // action
+  const applicationSubmissionid = match[2]; // id
+  const templateId = interaction.values[0];
+
+  if (action === 'acceptTemplate') {
+    await interaction.reply({
+      content: 'Accepting application',
+      ephemeral: true,
+    });
+    acceptApplicationSubmission(
+      applicationSubmissionid,
+      interaction.user.id,
+      templateId
+    );
+  }
+
+  if (action === 'denyTemplate') {
+    await interaction.reply({
+      content: 'Denying application',
+      ephemeral: true,
+    });
+    denyApplicationSubmission(
+      applicationSubmissionid,
+      interaction.user.id,
+      templateId
+    );
+  }
+};
diff --git a/events/interaction.js b/events/interaction.js
index 1a67213..5778e5d 100644
--- a/events/interaction.js
+++ b/events/interaction.js
@@ -31,3 +31,35 @@ export const commandsHandler = async (interaction) => {
     replyError(interaction, 'There was an error while executing this command!');
   }
 };
+
+export const modalHandler = async (interaction) => {
+  const modal = interaction.client.modals.get(interaction.customId);
+  if (interaction.customId.match(/^ticket-.?/)) {
+    return;
+  }
+  if (interaction.customId.match(/^applicationSubmission-.?/)) {
+    return;
+  }
+
+  if (!modal) {
+    Logger.error(`No modal matching ${interaction.customId} was found.`);
+    return;
+  }
+
+  try {
+    await modal.handler(interaction);
+  } catch (error) {
+    Logger.error(error);
+    if (interaction.replied || interaction.deferred) {
+      await interaction.followUp({
+        content: 'There was an error while handling the modal!',
+        ephemeral: true,
+      });
+    } else {
+      await interaction.reply({
+        content: 'There was an error while handling the modal!',
+        ephemeral: true,
+      });
+    }
+  }
+};
diff --git a/index.js b/index.js
index 22409b8..f607c8e 100644
--- a/index.js
+++ b/index.js
@@ -21,6 +21,7 @@ import {
   ticketMessageUpdateHandler,
   ticketMessageDeleteHandler,
 } from './events/ticket.js';
+import { applicationHandler } from './events/application.js';
 import { handleReactionRole } from './events/reactionRole.js';
 
 const intents = [
@@ -29,6 +30,7 @@ const intents = [
   GatewayIntentBits.GuildPresences,
   GatewayIntentBits.GuildMessages,
   GatewayIntentBits.GuildMessageReactions,
+  GatewayIntentBits.DirectMessages,
   GatewayIntentBits.MessageContent,
 ];
 const partials = [Partials.Message, Partials.Channel, Partials.Reaction];
@@ -43,6 +45,7 @@ client.on(Events.InteractionCreate, async (interaction) => {
     autocompleteHandler(interaction);
   }
   ticketHandler(interaction);
+  applicationHandler(interaction);
 });
 
 client.on(Events.MessageCreate, async (message) => {
diff --git a/tests/utils/logger.test.js b/tests/utils/logger.test.js
index a94f31d..3d99caa 100644
--- a/tests/utils/logger.test.js
+++ b/tests/utils/logger.test.js
@@ -15,20 +15,26 @@ afterEach(() => {
 it('should log debug messages with correct format', () => {
   Logger.debug('This is a debug message');
   expect(consoleLogMock).toHaveBeenCalledWith(
-    '[DEBUG]: This is a debug message'
+    expect.stringMatching(
+      /\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] \[DEBUG\]: This is a debug message/
+    )
   );
 });
 
 it('should log warning messages with correct format', () => {
   Logger.warning('This is a warning message');
   expect(consoleLogMock).toHaveBeenCalledWith(
-    '[WARNING]: This is a warning message'
+    expect.stringMatching(
+      /\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] \[WARNING\]: This is a warning message/
+    )
   );
 });
 
 it('should log error messages with correct format', () => {
   Logger.error('This is an error message');
   expect(consoleErrorMock).toHaveBeenCalledWith(
-    '[ERROR]: This is an error message'
+    expect.stringMatching(
+      /\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] \[ERROR\]: This is an error message/
+    )
   );
 });
diff --git a/utils/chunkText.js b/utils/chunkText.js
new file mode 100644
index 0000000..4818f43
--- /dev/null
+++ b/utils/chunkText.js
@@ -0,0 +1,37 @@
+export const chunkText = (str, maxLength = 1000) => {
+  const chunks = [];
+  let currentChunk = '';
+
+  const lines = str.split('\n');
+
+  for (const line of lines) {
+    if (currentChunk.length + line.length + 1 > maxLength) {
+      if (currentChunk) {
+        chunks.push(currentChunk.trim());
+        currentChunk = '';
+      }
+
+      if (line.length > maxLength) {
+        const words = line.split(' ');
+        for (const word of words) {
+          if (currentChunk.length + word.length + 1 > maxLength) {
+            chunks.push(currentChunk.trim());
+            currentChunk = word + ' ';
+          } else {
+            currentChunk += word + ' ';
+          }
+        }
+      } else {
+        currentChunk = line + '\n';
+      }
+    } else {
+      currentChunk += line + '\n';
+    }
+  }
+
+  if (currentChunk) {
+    chunks.push(currentChunk.trim());
+  }
+
+  return chunks;
+};
diff --git a/utils/logger.js b/utils/logger.js
index 6481f2f..a973fec 100644
--- a/utils/logger.js
+++ b/utils/logger.js
@@ -1,15 +1,20 @@
 /* eslint-disable no-console */
+import dayjs from 'dayjs';
+
+export default class Logger {
+  static getCurrentTime() {
+    return dayjs().format('YYYY-MM-DD HH:mm:ss');
+  }
 
-export default class Loggger {
   static debug = (message) => {
-    console.log(`[DEBUG]: ${message}`);
+    console.log(`[${Logger.getCurrentTime()}] [DEBUG]: ${message}`);
   };
 
   static warning = (message) => {
-    console.log(`[WARNING]: ${message}`);
+    console.log(`[${Logger.getCurrentTime()}] [WARNING]: ${message}`);
   };
 
   static error = (message) => {
-    console.error(`[ERROR]: ${message}`);
+    console.error(`[${Logger.getCurrentTime()}] [ERROR]: ${message}`);
   };
 }
diff --git a/vite.config.js b/vite.config.js
index 7136a84..88338bc 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -12,12 +12,6 @@ export default defineConfig({
     coverage: {
       provider: 'istanbul',
       reporter: ['text', 'json-summary', 'json'],
-      thresholds: {
-        lines: 52,
-        functions: 60,
-        branches: 44,
-        statements: 52,
-      },
     },
   },
 });