diff --git a/src/node.cc b/src/node.cc
index be9cd6442c5c18..0b3fc7e4d06de1 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -4369,10 +4369,9 @@ void FreeEnvironment(Environment* env) {
 }
 
 
-// Entry point for new node instances, also called directly for the main
-// node instance.
-static void StartNodeInstance(void* arg) {
-  NodeInstanceData* instance_data = static_cast<NodeInstanceData*>(arg);
+inline int Start(uv_loop_t* event_loop,
+                 int argc, const char* const* argv,
+                 int exec_argc, const char* const* exec_argv) {
   Isolate::CreateParams params;
   ArrayBufferAllocator array_buffer_allocator;
   params.array_buffer_allocator = &array_buffer_allocator;
@@ -4383,39 +4382,32 @@ static void StartNodeInstance(void* arg) {
 
   {
     Mutex::ScopedLock scoped_lock(node_isolate_mutex);
-    if (instance_data->is_main()) {
-      CHECK_EQ(node_isolate, nullptr);
-      node_isolate = isolate;
-    }
+    CHECK_EQ(node_isolate, nullptr);
+    node_isolate = isolate;
   }
 
   if (track_heap_objects) {
     isolate->GetHeapProfiler()->StartTrackingHeapObjects(true);
   }
 
+  int exit_code;
   {
     Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
-    IsolateData isolate_data(isolate, instance_data->event_loop(),
+    IsolateData isolate_data(isolate, event_loop,
                              array_buffer_allocator.zero_fill_field());
     Local<Context> context = Context::New(isolate);
     Context::Scope context_scope(context);
     Environment env(&isolate_data, context);
-    env.Start(instance_data->argc(),
-              instance_data->argv(),
-              instance_data->exec_argc(),
-              instance_data->exec_argv(),
-              v8_is_profiling);
+    env.Start(argc, argv, exec_argc, exec_argv, v8_is_profiling);
 
     isolate->SetAbortOnUncaughtExceptionCallback(
         ShouldAbortOnUncaughtException);
 
     // Start debug agent when argv has --debug
-    if (instance_data->use_debug_agent()) {
-      const char* path = instance_data->argc() > 1
-                         ? instance_data->argv()[1]
-                         : nullptr;
+    if (use_debug_agent) {
+      const char* path = argc > 1 ? argv[1] : nullptr;
       StartDebug(&env, path, debug_wait_connect);
       if (use_inspector && !debugger_running) {
         exit(12);
@@ -4430,7 +4422,7 @@ static void StartNodeInstance(void* arg) {
     env.set_trace_sync_io(trace_sync_io);
 
     // Enable debugger
-    if (instance_data->use_debug_agent())
+    if (use_debug_agent)
       EnableDebug(&env);
 
     {
@@ -4455,9 +4447,7 @@ static void StartNodeInstance(void* arg) {
 
     env.set_trace_sync_io(false);
 
-    int exit_code = EmitExit(&env);
-    if (instance_data->is_main())
-      instance_data->set_exit_code(exit_code);
+    exit_code = EmitExit(&env);
     RunAtExit(&env);
 
     WaitForInspectorDisconnect(&env);
@@ -4475,6 +4465,8 @@ static void StartNodeInstance(void* arg) {
   CHECK_NE(isolate, nullptr);
   isolate->Dispose();
   isolate = nullptr;
+
+  return exit_code;
 }
 
 int Start(int argc, char** argv) {
@@ -4505,19 +4497,8 @@ int Start(int argc, char** argv) {
   v8_platform.Initialize(v8_thread_pool_size);
   V8::Initialize();
   v8_initialized = true;
-
-  int exit_code = 1;
-  {
-    NodeInstanceData instance_data(NodeInstanceType::MAIN,
-                                   uv_default_loop(),
-                                   argc,
-                                   const_cast<const char**>(argv),
-                                   exec_argc,
-                                   exec_argv,
-                                   use_debug_agent);
-    StartNodeInstance(&instance_data);
-    exit_code = instance_data.exit_code();
-  }
+  const int exit_code =
+      Start(uv_default_loop(), argc, argv, exec_argc, exec_argv);
   v8_initialized = false;
   V8::Dispose();
 
diff --git a/src/node_internals.h b/src/node_internals.h
index 99b0cec2df2178..ae284660782cfe 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -179,87 +179,6 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
 // by clearing all callbacks that could handle the error.
 void ClearFatalExceptionHandlers(Environment* env);
 
-enum NodeInstanceType { MAIN, WORKER, REMOTE_DEBUG_SERVER };
-
-class NodeInstanceData {
- public:
-  NodeInstanceData(NodeInstanceType node_instance_type,
-                   uv_loop_t* event_loop,
-                   int argc,
-                   const char** argv,
-                   int exec_argc,
-                   const char** exec_argv,
-                   bool use_debug_agent_flag)
-      : node_instance_type_(node_instance_type),
-        exit_code_(1),
-        event_loop_(event_loop),
-        argc_(argc),
-        argv_(argv),
-        exec_argc_(exec_argc),
-        exec_argv_(exec_argv),
-        use_debug_agent_flag_(use_debug_agent_flag) {
-    CHECK_NE(event_loop_, nullptr);
-  }
-
-  uv_loop_t* event_loop() const {
-    return event_loop_;
-  }
-
-  int exit_code() {
-    CHECK(is_main());
-    return exit_code_;
-  }
-
-  void set_exit_code(int exit_code) {
-    CHECK(is_main());
-    exit_code_ = exit_code;
-  }
-
-  bool is_main() {
-    return node_instance_type_ == MAIN;
-  }
-
-  bool is_worker() {
-    return node_instance_type_ == WORKER;
-  }
-
-  bool is_remote_debug_server() {
-    return node_instance_type_ == REMOTE_DEBUG_SERVER;
-  }
-
-  int argc() {
-    return argc_;
-  }
-
-  const char** argv() {
-    return argv_;
-  }
-
-  int exec_argc() {
-    return exec_argc_;
-  }
-
-  const char** exec_argv() {
-    return exec_argv_;
-  }
-
-  bool use_debug_agent() {
-    return is_main() && use_debug_agent_flag_;
-  }
-
- private:
-  const NodeInstanceType node_instance_type_;
-  int exit_code_;
-  uv_loop_t* const event_loop_;
-  const int argc_;
-  const char** argv_;
-  const int exec_argc_;
-  const char** exec_argv_;
-  const bool use_debug_agent_flag_;
-
-  DISALLOW_COPY_AND_ASSIGN(NodeInstanceData);
-};
-
 namespace Buffer {
 v8::MaybeLocal<v8::Object> Copy(Environment* env, const char* data, size_t len);
 v8::MaybeLocal<v8::Object> New(Environment* env, size_t size);