List the phases of the JavaScript Execution Context.

There are two phases of JavaScript execution context:

Creation phase:

1
In this phase, the JavaScript engine creates the execution context and sets up the script's environment.
2
It determines the values of functions ,declare variables and
3
sets up the scope chain for the execution context.

Execution phase:

1
In this phase, the JavaScript engine executes the code in the execution context.
2
It processes any statements or expressions in the script and evaluates function calls.

Difficulty: 3/10

Topics: creation phase, execution phase, variable environment

0-2 years experience

1
If you write a simple function that logs a variable declared with var, can you walk me through the steps the engine takes before the console.log executes?
2
When you call a function that contains a nested function, describe the phases the JavaScript engine creates for each call.
3
What would you see if you try to access a let‑declared variable before its declaration inside a function?

2-5 years experience

1
We have a bug where a function sometimes sees an undefined variable even though it's declared later in the file. How would you use the execution context phases to debug it?
2
During a refactor you moved some code into a separate module and now a function throws a ReferenceError. Explain which phase likely caused the error and why.
3
If you need to capture the current value of a variable when creating a callback, how do the creation and execution phases affect your approach?

5-8 years experience

1
Our web app shows memory leaks after many dynamic function creations. How might the creation and execution phases of execution contexts contribute to the leak, and what design changes would you suggest?
2
When building a custom async scheduler, how do execution context phases interact with the call stack and event loop, and what pitfalls should we watch for?
3
If we wanted to sandbox third‑party scripts, how could we leverage the phases of execution contexts to isolate their variable environments?

8+ years experience

1
We’re migrating a large legacy codebase to ES modules and want strict boundaries between execution contexts. How would you architect tooling or runtime changes to control creation and execution phases across modules?
2
At a platform level, how could you redesign the execution context lifecycle to improve startup performance for massive single‑page applications?
3
When designing a secure multi‑tenant JavaScript platform, how would you use execution context phases to enforce isolation and prevent cross‑tenant state leakage?