Arduino Micro: 69 is supposed to show up when I press 1 on the keypad, however some weird number (15 in this case) is showing up
According to the documentation, the getKey() function is
non blocking. This means it does not wait for a key to be pressed:
it instead returns immediately whether a key has been pressed or not. If
no key has been pressed (i.e. most of the time), it returns a NUL
character, which has the numeric value zero and evaluates to false in
a boolean context. Hence the idiom:
char key = keypad.getKey();
if (key) {  // if a key has actually been pressed
    // handle it
}

The CountDownSequence() function fails to account for this:
void CountDownSequence() {
  char key = keypad.getKey();  // no check for NUL
  
  if (key == '0') {
    timeV = timeV + 0;  // this has no effect at all
  }

  if (key == '1') {
    timeV = 69;  // this is what you would expect to be executed
  }

  countDownDetect = false;  // these two lines tell the rest of the
  countDownOutput = true;   // program that we are done.
}

Since key will almost certainly be '\0', the program will move to
the next step without ever initializing timeV.
As a side note, I recommend you try to rewrite your program as a finite
state machine. A single state variable would make it less
confusing and easier to understand than the current collections of
booleans.

Edit: Expanding on the idea of the finite state machine. I tried an
implementation of your concept based on it.
For handling a menu system, where the user can navigate through several
on-screen “pages”, the most obvious first approach is to have one state
per page displayed. For this program, these states could be:

MENU, which offers the choice to move to either of the following two
pages
SET_COUNT allows the user to set the countdown duration
TWR allows him to compute the thrust/weight ratio
COUNT_DOWN actually runs the countdown timer

In the following, I added an extra transitional state called START
that comes right before MENU. This is not required, and its only
purpose is to avoid code repetition by having a single transition
(START → MENU) responsible for actually drawing the menu.
When implementing a finite state machine, my first recommendation would
be to start by drawing a state diagram like this:

In this diagram, each transition is labeled with the event that triggers
it. The events are key presses, save for “finished” which means that the
countdown is done. The state diagram can become significantly more
complex than this as you add new functionality. It is, however, a very
good way of designing your system from the point of view of user
interaction.
Once you are happy with the state diagram, the coding is just a matter
of translating it to a switch/case construct, with one case per
state. Here is my take at it:
/*
   Jebediah's Launch Control System for Kerbal Space Program
   Alpha Build 0.70
   An Open-Source Project by John Seong
*/

#include &lt;Wire.h&gt;
#include &lt;LiquidCrystal_I2C.h&gt;
#include &lt;Keypad.h&gt;

const byte ROWS = 4;
const byte COLS = 3;

char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'}
};

byte rowPins[ROWS] = {12, 11, 10, 9};
byte colPins[COLS] = {8, 7, 6};

Keypad keypad=Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

// Show a two-line message on the LCD.
void lcdShow(const char *line0, const char *line1) {
  lcd.clear();
  lcd.print(line0);
  lcd.setCursor(0, 1);
  lcd.print(line1);
}

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcdShow(&quot;Jeb's Launch&quot;, &quot;Control System&quot;);
  delay(3000);
  lcdShow(&quot;Alpha Build 0.70&quot;, &quot; STUDIO HORIZON&quot;);
  delay(3000);
  lcdShow(&quot;Welcome, Kerman&quot;, &quot;Press any key...&quot;);
  while (!keypad.getKey()) ;  // wait for key press
}

void loop() {
  static enum {START, MENU, SET_COUNT, COUNT_DOWN, TWR} state = START;
  static uint32_t last_second;  // millis() value on last full second
  static int count;             // countdown value

  char key = keypad.getKey();

  switch (state) {
    case START:  // transitional state
      lcdShow(&quot;1. Countdown&quot;, &quot;2. TWR&quot;);
      state = MENU;
      /* fallthrough */
    case MENU:
      if (key == '1') {  // Countdown
        lcdShow(&quot;Enter time&quot;, &quot;seconds: &quot;);
        count = 0;
        state = SET_COUNT;
      } else if (key == '2') {  // TWR
        lcdShow(&quot;Thrust:&quot;, &quot;# to continue...&quot;);
        state = TWR;
      }
      break;
    case SET_COUNT:
      if (key &gt;= '0' &amp;&amp; key &lt;= '9' &amp;&amp; count &lt;= 99) {
        lcd.print(key);
        count = 10 * count + (key - '0');
      } else if (key == '#') {
        lcdShow(&quot;Take off in&quot;, &quot;     seconds&quot;);
        // Force a refresh on entering COUNT_DOWN:
        last_second = millis() - 1000;
        count++;
        state = COUNT_DOWN;
      } else if (key == '*') {
        state = START;
      }
      break;
    case COUNT_DOWN:
      if (millis() - last_second &gt;= 1000) {
        last_second += 1000;
        count--;
        if (count == 0) {
          Serial.println(&quot;Take off!&quot;);
        } else if (count &lt; 0) {
          state = START;
          break;
        }
        lcd.setCursor(1, 1);
        lcd.print(count&lt;10 ? &quot;  &quot; : count&lt;100 ? &quot; &quot; : &quot;&quot;);  // pad
        lcd.print(count);
      } else if (key == '*') {
        state = START;
      }
      break;
    case TWR:
      if (key == '*' || key == '#') {
        state = START;
      }
      break;
  }
}

Note the comment “fallthrough” between START and MENU. This
indicates that the lack of break at this place is intended: the
processing of the MENU case will follow right after the processing of
the START case, in the same loop iteration. The purpose of the fall
through is to not loose the current key press, if any. If this is not
important, you could put a regular break here and defer the handling
of MENU to the next loop iteration.
Note also that the key presses are checked with tests of the form
if (key == SOME_VALUE), which means there is no need for an extra
if (key) to test whether there was an actual key press.