diff --git a/doc/api/cli.md b/doc/api/cli.md
index 9c5af91ae13f91..bf12672d6dafca 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -911,6 +911,36 @@ added: v23.6.0
 
 Enable experimental import support for `.node` addons.
 
+### `--experimental-config-file`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.0 - Early development
+
+Use this flag to specify a configuration file that will be loaded and parsed
+before the application starts.
+Node.js will read the configuration file and apply the settings as
+[`NODE_OPTIONS`][].
+The configuration file should be a JSON file
+with the following structure:
+
+```json
+{
+  "version": 0,
+  "experimental_transform_types": true
+}
+```
+
+Currently the only supported version is 0.
+The configuration file cannot be used in conjuction with `--env-file`.
+The configuration file cannot be used if [`NODE_OPTIONS`][] are set.
+The configuration file will not override the flag passed in the command line.
+If multiple keys are present in the configuration file, only the first one
+will be considered and the followin will be ignored.
+Unknown keys will be ignored.
+
 ### `--experimental-eventsource`
 
 <!-- YAML
diff --git a/doc/node.1 b/doc/node.1
index d33bb82b7670e7..ad8873b423105c 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -166,6 +166,9 @@ Interpret the entry point as a URL.
 .It Fl -experimental-addon-modules
 Enable experimental addon module support.
 .
+.It Fl -experimental-config-file
+Enable support for experimental config file
+.
 .It Fl -experimental-import-meta-resolve
 Enable experimental ES modules support for import.meta.resolve().
 .
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 109890e5986ee4..537d0a7b39b682 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -116,6 +116,8 @@ function prepareExecution(options) {
   initializeSourceMapsHandlers();
   initializeDeprecations();
 
+  setupConfigFile();
+
   require('internal/dns/utils').initializeDns();
 
   if (isMainThread) {
@@ -312,6 +314,12 @@ function setupSQLite() {
   BuiltinModule.allowRequireByUsers('sqlite');
 }
 
+function setupConfigFile() {
+  if (getOptionValue('--experimental-config-file')) {
+    emitExperimentalWarning('--experimental-config-file');
+  }
+}
+
 function setupQuic() {
   if (!getOptionValue('--experimental-quic')) {
     return;
diff --git a/node.gyp b/node.gyp
index ba1f50d7541cca..1e246a0d0a6ae7 100644
--- a/node.gyp
+++ b/node.gyp
@@ -130,6 +130,7 @@
       'src/node_process_events.cc',
       'src/node_process_methods.cc',
       'src/node_process_object.cc',
+      'src/node_rc.cc',
       'src/node_realm.cc',
       'src/node_report.cc',
       'src/node_report_module.cc',
@@ -262,6 +263,7 @@
       'src/node_platform.h',
       'src/node_process.h',
       'src/node_process-inl.h',
+      'src/node_rc.h',
       'src/node_realm.h',
       'src/node_realm-inl.h',
       'src/node_report.h',
diff --git a/src/node.cc b/src/node.cc
index 6b5ae7f7e455f8..6291866ac7856c 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -21,6 +21,7 @@
 
 #include "node.h"
 #include "node_dotenv.h"
+#include "node_rc.h"
 #include "node_task_runner.h"
 
 // ========== local headers ==========
@@ -150,6 +151,9 @@ namespace per_process {
 // Instance is used to store environment variables including NODE_OPTIONS.
 node::Dotenv dotenv_file = Dotenv();
 
+// node_rc.h
+node::ConfigReader config_reader = ConfigReader();
+
 // node_revert.h
 // Bit flag used to track security reverts.
 unsigned int reverted_cve = 0;
@@ -884,6 +888,32 @@ static ExitCode InitializeNodeWithArgsInternal(
     per_process::dotenv_file.AssignNodeOptionsIfAvailable(&node_options);
   }
 
+  auto result = per_process::config_reader.GetDataFromArgs(*argv);
+  // Skip if env_files is not empty, as it has already been processed.
+  if (result.has_value() && !env_files.empty()) {
+    errors->push_back(
+      "--experimental-config-file cannot be used with .env files");
+    return ExitCode::kInvalidCommandLineArgument;
+  }
+  if (result.has_value() && env_files.empty()) {
+    switch (per_process::config_reader.ParseConfig(result.value())) {
+      case ConfigReader::ParseResult::Valid:
+        break;
+      case ConfigReader::ParseResult::InvalidContent:
+        errors->push_back(result.value() + ": invalid format");
+        break;
+      case ConfigReader::ParseResult::FileError:
+        errors->push_back(result.value() + ": not found");
+        break;
+      case ConfigReader::ParseResult::InvalidVersion:
+        errors->push_back(result.value() + ": invalid version");
+        break;
+      default:
+        UNREACHABLE();
+    }
+    per_process::config_reader.AssignNodeOptions(&node_options);
+  }
+
 #if !defined(NODE_WITHOUT_NODE_OPTIONS)
   if (!(flags & ProcessInitializationFlags::kDisableNodeOptionsEnv)) {
     // NODE_OPTIONS environment variable is preferred over the file one.
diff --git a/src/node_options.cc b/src/node_options.cc
index a6dc00d7d7213f..e013a8978544db 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -671,6 +671,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "set environment variables from supplied file",
             &EnvironmentOptions::optional_env_file);
   Implies("--env-file-if-exists", "[has_env_file_string]");
+  AddOption("--experimental-config-file",
+            "set config file from supplied file",
+            &EnvironmentOptions::experimental_config_file);
   AddOption("--test",
             "launch test runner on startup",
             &EnvironmentOptions::test_runner);
diff --git a/src/node_options.h b/src/node_options.h
index 3c4d2f853f2b35..02ef5708c85fce 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -256,6 +256,7 @@ class EnvironmentOptions : public Options {
 
   bool report_exclude_env = false;
   bool report_exclude_network = false;
+  std::string experimental_config_file;
 
   inline DebugOptions* get_debug_options() { return &debug_options_; }
   inline const DebugOptions& debug_options() const { return debug_options_; }
diff --git a/src/node_rc.cc b/src/node_rc.cc
new file mode 100644
index 00000000000000..11781623edb720
--- /dev/null
+++ b/src/node_rc.cc
@@ -0,0 +1,133 @@
+#include "node_rc.h"
+#include "debug_utils-inl.h"
+#include "env-inl.h"
+#include "node_errors.h"
+#include "node_file.h"
+#include "node_internals.h"
+#include "simdjson.h"
+
+#include <functional>
+#include <map>
+#include <string>
+
+namespace node {
+
+std::optional<ConfigReader::ConfigV0> ConfigReader::ParseConfigV0(
+    simdjson::ondemand::object* main_object) {
+  ConfigReader::ConfigV0 config;
+  config.version = 0;
+
+  if (auto value = (*main_object)["experimental_transform_types"];
+      value.error() != simdjson::NO_SUCH_FIELD) {
+    if (value.get_bool().get(config.experimental_transform_types)) {
+      FPrintF(stderr, "Invalid value for experimental_transform_types\n");
+      return std::nullopt;
+    }
+  }
+
+  return config;
+}
+
+ConfigReader::ConfigReader() {
+  config_parsers_[0] = &ConfigReader::ParseConfigV0;
+}
+
+std::optional<std::string> ConfigReader::GetDataFromArgs(
+    const std::vector<std::string>& args) {
+  constexpr std::string_view flag = "--experimental-config-file";
+
+  for (auto it = args.begin(); it != args.end(); ++it) {
+    if (*it == flag) {
+      // Case: "--experimental-config-file foo"
+      if (auto next = std::next(it); next != args.end()) {
+        return *next;
+      }
+    } else if (it->starts_with(flag)) {
+      // Case: "--experimental-config-file=foo"
+      if (it->size() > flag.size() && (*it)[flag.size()] == '=') {
+        return it->substr(flag.size() + 1);
+      }
+    }
+  }
+
+  return std::nullopt;
+}
+
+ConfigReader::ParseResult ConfigReader::ParseConfig(
+    const std::string& config_path) {
+  std::string file_content;
+  // Read the configuration file
+  int r = ReadFileSync(&file_content, config_path.c_str());
+  if (r != 0) {
+    const char* err = uv_strerror(r);
+    FPrintF(
+        stderr, "Cannot read configuration from %s: %s\n", config_path, err);
+    return ParseResult::FileError;
+  }
+
+  // Parse the configuration file
+  simdjson::ondemand::parser json_parser;
+  simdjson::ondemand::document document;
+  if (json_parser.iterate(file_content).get(document)) {
+    FPrintF(stderr, "Can't parse %s\n", config_path.c_str());
+    return ParseResult::InvalidContent;
+  }
+
+  simdjson::ondemand::object main_object;
+  // If document is not an object, throw an error.
+  if (auto root_error = document.get_object().get(main_object)) {
+    if (root_error == simdjson::error_code::INCORRECT_TYPE) {
+      FPrintF(stderr,
+              "Root value unexpected not an object for %s\n\n",
+              config_path.c_str());
+    } else {
+      FPrintF(stderr, "Can't parse %s\n", config_path.c_str());
+    }
+    return ParseResult::InvalidContent;
+  }
+
+  // If json object doesn't have "version" field, throw an error.
+  simdjson::ondemand::number version_field;
+  if (main_object["version"].get_number().get(version_field)) {
+    FPrintF(stderr,
+            "Can't find numeric \"version\" field in %s\n",
+            config_path.c_str());
+    return ParseResult::InvalidVersion;
+  }
+
+  // Check if version is an integer
+  if (!version_field.is_int64()) {
+    FPrintF(
+        stderr, "Version field is not an integer in %s\n", config_path.c_str());
+    return ParseResult::InvalidVersion;
+  }
+
+  uint64_t version = version_field.get_int64();
+  if (version < 0 || version >= config_parsers_.size()) {
+    FPrintF(stderr, "Version %" PRIu64 " does not exist\n", version);
+    return ParseResult::InvalidVersion;
+  }
+
+  // Get the config parser for the specific version
+  auto config_parser = config_parsers_.at(version_field.get_int64());
+  auto config = config_parser(&main_object);
+  if (!config.has_value()) {
+    return ParseResult::InvalidContent;
+  }
+
+  // save the config for later
+  config_ = config.value();
+  return ParseResult::Valid;
+}
+
+void ConfigReader::AssignNodeOptions(std::string* node_options) {
+  if (ConfigV0* config = std::get_if<ConfigReader::ConfigV0>(&config_)) {
+    std::string result = "";
+    if (config->experimental_transform_types) {
+      result += "--experimental-transform-types";
+    }
+    *node_options = result;
+    return;
+  }
+}
+}  // namespace node
diff --git a/src/node_rc.h b/src/node_rc.h
new file mode 100644
index 00000000000000..8ab0b389df94df
--- /dev/null
+++ b/src/node_rc.h
@@ -0,0 +1,49 @@
+#ifndef SRC_NODE_RC_H_
+#define SRC_NODE_RC_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <map>
+#include <string>
+#include <variant>
+#include "simdjson.h"
+#include "util-inl.h"
+
+namespace node {
+
+class ConfigReader {
+ public:
+  enum ParseResult { Valid, FileError, InvalidContent, InvalidVersion };
+  struct ConfigV0 {
+    int64_t version;
+    bool experimental_transform_types;
+  };
+  using Config = std::variant<ConfigV0>;
+  using ConfigParser =
+      std::function<std::optional<Config>(simdjson::ondemand::object*)>;
+
+  ConfigReader();
+
+  ConfigReader::ParseResult ParseConfig(const std::string& config_path);
+
+  std::optional<std::string> GetDataFromArgs(
+      const std::vector<std::string>& args);
+
+  void AssignNodeOptions(std::string* node_options);
+
+ private:
+  simdjson::ondemand::parser json_parser_;
+
+  ConfigReader::Config config_;
+
+  static std::optional<ConfigReader::ConfigV0> ParseConfigV0(
+    simdjson::ondemand::object* main_object);
+
+  std::array<ConfigParser, 1> config_parsers_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_RC_H_
diff --git a/test/fixtures/rc/empty-object.json b/test/fixtures/rc/empty-object.json
new file mode 100644
index 00000000000000..f5ed717bad58ad
--- /dev/null
+++ b/test/fixtures/rc/empty-object.json
@@ -0,0 +1,4 @@
+{
+
+}
+
diff --git a/test/fixtures/rc/empty.json b/test/fixtures/rc/empty.json
new file mode 100644
index 00000000000000..8b137891791fe9
--- /dev/null
+++ b/test/fixtures/rc/empty.json
@@ -0,0 +1 @@
+
diff --git a/test/fixtures/rc/non-existing-version.json b/test/fixtures/rc/non-existing-version.json
new file mode 100644
index 00000000000000..61d1225828d409
--- /dev/null
+++ b/test/fixtures/rc/non-existing-version.json
@@ -0,0 +1,3 @@
+{
+    "version": 9999
+}
diff --git a/test/fixtures/rc/non-numeric-version.json b/test/fixtures/rc/non-numeric-version.json
new file mode 100644
index 00000000000000..1928e8168ac3cc
--- /dev/null
+++ b/test/fixtures/rc/non-numeric-version.json
@@ -0,0 +1,3 @@
+{
+    "version": "foo"
+}
diff --git a/test/fixtures/rc/override-property.json b/test/fixtures/rc/override-property.json
new file mode 100644
index 00000000000000..2ecae1f985411d
--- /dev/null
+++ b/test/fixtures/rc/override-property.json
@@ -0,0 +1,5 @@
+{
+    "version": 0,
+    "experimental_transform_types": true,
+    "experimental_transform_types": false
+}
diff --git a/test/fixtures/rc/override-version.json b/test/fixtures/rc/override-version.json
new file mode 100644
index 00000000000000..9b6d68b4599da4
--- /dev/null
+++ b/test/fixtures/rc/override-version.json
@@ -0,0 +1,4 @@
+{
+    "version": 0,
+    "version": 9999
+}
diff --git a/test/fixtures/rc/transform-types.json b/test/fixtures/rc/transform-types.json
new file mode 100644
index 00000000000000..da620ea0ec20a6
--- /dev/null
+++ b/test/fixtures/rc/transform-types.json
@@ -0,0 +1,4 @@
+{
+    "version": 0,
+    "experimental_transform_types": true
+}
diff --git a/test/fixtures/rc/version-only.json b/test/fixtures/rc/version-only.json
new file mode 100644
index 00000000000000..27f915fa61055c
--- /dev/null
+++ b/test/fixtures/rc/version-only.json
@@ -0,0 +1,3 @@
+{
+    "version": 0
+}
diff --git a/test/parallel/test-config_rc.js b/test/parallel/test-config_rc.js
new file mode 100644
index 00000000000000..1d8b2a4a8a609a
--- /dev/null
+++ b/test/parallel/test-config_rc.js
@@ -0,0 +1,137 @@
+'use strict';
+
+const { spawnPromisified } = require('../common');
+const fixtures = require('../common/fixtures');
+const { notStrictEqual, match, strictEqual } = require('node:assert');
+const { test } = require('node:test');
+
+test('should handle empty json', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-config-file',
+    fixtures.path('rc/empty.json'),
+    '-p', '"Hello, World!"',
+  ]);
+  match(result.stderr, /Can't parse/);
+  match(result.stderr, /empty\.json: invalid format/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});
+
+test('should handle empty object json', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-config-file',
+    fixtures.path('rc/empty-object.json'),
+    '-p', '"Hello, World!"',
+  ]);
+  match(result.stderr, /Can't find numeric "version" field in/);
+  match(result.stderr, /empty-object\.json: invalid version\n/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});
+
+test('should handle non numeric version', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-config-file',
+    fixtures.path('rc/non-numeric-version.json'),
+    '-p', '"Hello, World!"',
+  ]);
+  match(result.stderr, /Can't find numeric "version" field/);
+  match(result.stderr, /non-numeric-version\.json: invalid version/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});
+
+test('should handle non existing version', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-config-file',
+    fixtures.path('rc/non-existing-version.json'),
+    '-p', '"Hello, World!"',
+  ]);
+  match(result.stderr, /Version 9999 does not exist/);
+  match(result.stderr, /non-existing-version\.json: invalid version/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});
+
+test('should parse version 0 with experimental_transform_types true', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-config-file',
+    fixtures.path('rc/transform-types.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ]);
+  match(result.stderr, /--experimental-config-file is an experimental feature and might change at any time/);
+  match(result.stdout, /Hello, TypeScript!/);
+  strictEqual(result.code, 0);
+});
+
+test('should parse version only', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--experimental-config-file',
+    fixtures.path('rc/version-only.json'),
+    '-p', '"Hello, World!"',
+  ]);
+  match(result.stdout, /Hello, World!/);
+  strictEqual(result.stderr, '');
+  strictEqual(result.code, 0);
+});
+
+test('should ignore overriding experimental_transform_types', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--experimental-config-file',
+    fixtures.path('rc/override-property.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ]);
+  strictEqual(result.stderr, '');
+  match(result.stdout, /Hello, TypeScript!/);
+  strictEqual(result.code, 0);
+});
+
+test('should not work when env-file is passed', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--env-file', fixtures.path('dotenv/valid.env'),
+    '--experimental-config-file',
+    fixtures.path('rc/transform-types.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ]);
+  match(result.stderr, /--experimental-config-file cannot be used with \.env files/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});
+
+test('should not work when when NODE_OPTIONS are passed', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--experimental-config-file',
+    fixtures.path('rc/transform-types.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ], {
+    env: {
+      ...process.env,
+      NODE_OPTIONS: '--no-experimental-transform-types',
+    },
+  });
+  match(result.stderr, /ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});
+
+test('should not work when when NODE_OPTIONS are passed', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--no-warnings',
+    '--no-experimental-transform-types',
+    '--experimental-config-file',
+    fixtures.path('rc/transform-types.json'),
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ], {
+    env: {
+      ...process.env,
+      NODE_OPTIONS: '--no-experimental-transform-types',
+    },
+  });
+  match(result.stderr, /ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX/);
+  strictEqual(result.stdout, '');
+  notStrictEqual(result.code, 0);
+});