diff --git a/doc/api/cli.md b/doc/api/cli.md
index 989a8cce13aa46..0bda4426cff709 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -905,6 +905,29 @@ Export keyword before a key is ignored:
 export USERNAME="nodejs" # will result in `nodejs` as the value.
 ```
 
+Additionally sections can be used to have a more granular control of
+the environment variables within a single file.
+
+Sections can be defined in the file and then targeted by including a hash character
+followed by their name as the flag's argument. Multiple sections can be specified and
+if a variable is defined in multiple sections the latest instance of the variable in
+the file overrides the others.
+
+For example given the following file:
+
+```text
+MY_VAR = 'my top-level variable'
+
+[dev]
+MY_VAR = 'my variable for development'
+
+[prod]
+MY_VAR = 'my variable for production'
+```
+
+`--env-file=config#dev` will make it so that the variable's value being used is
+taken from the `dev` section.
+
 If you want to load environment variables from a file that may not exist, you
 can use the [`--env-file-if-exists`][] flag instead.
 
diff --git a/doc/api/process.md b/doc/api/process.md
index b3c74c99ec49b4..3db6bc06a50bc4 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -2791,6 +2791,10 @@ added:
 
 * `path` {string | URL | Buffer | undefined}. **Default:** `'./.env'`
 
+* `options`
+
+  * `sections` {string\[]} (optional) The sections to use.
+
 Loads the `.env` file into `process.env`. Usage of `NODE_OPTIONS`
 in the `.env` file will not have any effect on Node.js.
 
diff --git a/doc/api/util.md b/doc/api/util.md
index 1de5ea1515e918..540a94af264da7 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -2133,7 +2133,7 @@ $ node negate.js --no-logfile --logfile=test.log --color --no-color
 { logfile: 'test.log', color: false }
 ```
 
-## `util.parseEnv(content)`
+## `util.parseEnv(content, sections)`
 
 <!-- YAML
 added:
@@ -2143,28 +2143,72 @@ added:
 
 > Stability: 1.1 - Active development
 
-* `content` {string}
+* `content` {string} The con
+  The raw contents of a `.env` file.
 
-The raw contents of a `.env` file.
+* `options`
+
+  * `sections` {string\[]} (optional)
+    The sections to take from the content
 
 * Returns: {Object}
 
-Given an example `.env` file:
+Examples:
 
 ```cjs
 const { parseEnv } = require('node:util');
 
-parseEnv('HELLO=world\nHELLO=oh my\n');
+parseEnv(`
+HELLO=world
+HELLO=oh my
+`);
 // Returns: { HELLO: 'oh my' }
 ```
 
 ```mjs
 import { parseEnv } from 'node:util';
 
-parseEnv('HELLO=world\nHELLO=oh my\n');
+parseEnv(`
+HELLO=world
+HELLO=oh my
+`);
 // Returns: { HELLO: 'oh my' }
 ```
 
+```cjs
+const { parseEnv } = require('node:util');
+
+parseEnv(`
+  X = x
+  Y = y
+
+  [section-a]
+  X = x_a
+
+  [section-b]
+  Y = y_b
+  Z = z_b
+`, { sections: ['section-b'] });
+// Returns: { X: 'x', Y: 'y_b', Z: 'z_b' }
+```
+
+```mjs
+import { parseEnv } from 'node:util';
+
+parseEnv(`
+  X = x
+  Y = y
+
+  [section-a]
+  X = x_a
+
+  [section-b]
+  Y = y_b
+  Z = z_b
+`, { sections: ['section-b'] });
+// Returns: { X: 'x', Y: 'y_b', Z: 'z_b' }
+```
+
 ## `util.promisify(original)`
 
 <!-- YAML
diff --git a/lib/internal/process/per_thread.js b/lib/internal/process/per_thread.js
index 36ac1046dab471..26019e5d660da0 100644
--- a/lib/internal/process/per_thread.js
+++ b/lib/internal/process/per_thread.js
@@ -52,6 +52,7 @@ const {
   validateNumber,
   validateObject,
   validateString,
+  validateStringArray,
 } = require('internal/validators');
 
 const dc = require('diagnostics_channel');
@@ -354,15 +355,15 @@ function wrapProcessMethods(binding) {
   /**
    * Loads the `.env` file to process.env.
    * @param {string | URL | Buffer | undefined} path
+   * @param {{ sections?: string[] }} [options]
    */
-  function loadEnvFile(path = undefined) { // Provide optional value so that `loadEnvFile.length` returns 0
-    if (path != null) {
-      getValidatedPath ??= require('internal/fs/utils').getValidatedPath;
-      path = getValidatedPath(path);
-      _loadEnvFile(path);
-    } else {
-      _loadEnvFile();
+  function loadEnvFile(path = '.env', options = {}) {
+    getValidatedPath ??= require('internal/fs/utils').getValidatedPath;
+    path = getValidatedPath(path);
+    if ('sections' in options) {
+      validateStringArray(options.sections, 'options.section');
     }
+    _loadEnvFile(path, options.sections ?? []);
   }
 
   return {
diff --git a/lib/util.js b/lib/util.js
index a422daa212b855..fe789e465fd34c 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -61,6 +61,7 @@ const {
   validateFunction,
   validateNumber,
   validateString,
+  validateStringArray,
   validateOneOf,
   validateObject,
 } = require('internal/validators');
@@ -316,11 +317,15 @@ function _exceptionWithHostPort(...args) {
 /**
  * Parses the content of a `.env` file.
  * @param {string} content
+ * @param {{ sections?: string[] }} [options]
  * @returns {Record<string, string>}
  */
-function parseEnv(content) {
+function parseEnv(content, options = {}) {
   validateString(content, 'content');
-  return binding.parseEnv(content);
+  if ('sections' in options.sections) {
+    validateStringArray(options.sections, 'options.section');
+  }
+  return binding.parseEnv(content, options.sections ?? []);
 }
 
 const lazySourceMap = getLazy(() => require('internal/source_map/source_map_cache'));
diff --git a/src/node.cc b/src/node.cc
index 1df469d8b60c06..0e0e86a0d085b3 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -873,7 +873,8 @@ static ExitCode InitializeNodeWithArgsInternal(
     CHECK(!per_process::v8_initialized);
 
     for (const auto& file_data : env_files) {
-      switch (per_process::dotenv_file.ParsePath(file_data.path)) {
+      switch (per_process::dotenv_file.ParsePath(file_data.path,
+                                                 file_data.sections)) {
         case Dotenv::ParseResult::Valid:
           break;
         case Dotenv::ParseResult::InvalidContent:
diff --git a/src/node_dotenv.cc b/src/node_dotenv.cc
index 3bdeaab1a9cb23..5cf057edd97442 100644
--- a/src/node_dotenv.cc
+++ b/src/node_dotenv.cc
@@ -1,4 +1,5 @@
 #include "node_dotenv.h"
+#include <string_view>
 #include <unordered_set>
 #include "env-inl.h"
 #include "node_file.h"
@@ -26,6 +27,33 @@ std::vector<Dotenv::env_file_data> Dotenv::GetDataFromArgs(
            arg.starts_with("--env-file-if-exists=");
   };
 
+  const auto get_sections = [](const std::string& path) {
+    std::set<std::string> sections = {};
+    std::int8_t start_index = 0;
+
+    while (true) {
+      auto hash_char_index = path.find('#', start_index);
+      if (hash_char_index == std::string::npos) {
+        return sections;
+      }
+      auto next_hash_char_index = path.find('#', hash_char_index + 1);
+      if (next_hash_char_index == std::string::npos) {
+        // We've arrived to the last section
+        auto section = path.substr(hash_char_index + 1);
+        sections.insert(section);
+        return sections;
+      }
+      // There are more sections, so let's save the current one and update the
+      // index
+      auto section = path.substr(hash_char_index + 1,
+                                 next_hash_char_index - 1 - hash_char_index);
+      sections.insert(section);
+      start_index = next_hash_char_index;
+    }
+
+    return sections;
+  };
+
   std::vector<Dotenv::env_file_data> env_files;
   // This will be an iterator, pointing to args.end() if no matches are found
   auto matched_arg = std::find_if(args.begin(), args.end(), find_match);
@@ -42,19 +70,37 @@ std::vector<Dotenv::env_file_data> Dotenv::GetDataFromArgs(
       auto flag = matched_arg->substr(0, equal_char_index);
       auto file_path = matched_arg->substr(equal_char_index + 1);
 
+      auto sections = get_sections(file_path);
+
+      auto hash_char_index = file_path.find('#');
+      if (hash_char_index != std::string::npos) {
+        file_path = file_path.substr(0, hash_char_index);
+      }
+
       struct env_file_data env_file_data = {
-          file_path, flag.starts_with(optional_env_file_flag)};
+          file_path, flag.starts_with(optional_env_file_flag), sections};
       env_files.push_back(env_file_data);
     } else {
       // `--env-file path`
-      auto file_path = std::next(matched_arg);
+      auto file_path_ptr = std::next(matched_arg);
 
-      if (file_path == args.end()) {
+      if (file_path_ptr == args.end()) {
         return env_files;
       }
 
+      std::string file_path = file_path_ptr->c_str();
+
+      auto sections = get_sections(file_path);
+
+      auto hash_char_index = file_path.find('#');
+      if (hash_char_index != std::string::npos) {
+        file_path = file_path.substr(0, hash_char_index);
+      }
+
       struct env_file_data env_file_data = {
-          *file_path, matched_arg->starts_with(optional_env_file_flag)};
+          file_path,
+          matched_arg->starts_with(optional_env_file_flag),
+          sections};
       env_files.push_back(env_file_data);
     }
 
@@ -124,9 +170,24 @@ std::string_view trim_spaces(std::string_view input) {
   return input.substr(pos_start, pos_end - pos_start + 1);
 }
 
-void Dotenv::ParseContent(const std::string_view input) {
+void Dotenv::ParseContent(const std::string_view input,
+                          const std::set<std::string> sections) {
   std::string lines(input);
 
+  // Variable to track the current section ("" indicates that we're in the
+  // global/top-level section)
+  std::string current_section = "";
+
+  // Insert/Assign a value in the store, but only if it's in the global section
+  // or in an included section
+  auto maybe_insert_or_assign_to_store = [&](const std::string& key,
+                                             const std::string_view& value) {
+    if (current_section.empty() ||
+        (sections.find(current_section.c_str()) != sections.end())) {
+      store_.insert_or_assign(key, value);
+    }
+  };
+
   // Handle windows newlines "\r\n": remove "\r" and keep only "\n"
   lines.erase(std::remove(lines.begin(), lines.end(), '\r'), lines.end());
 
@@ -154,6 +215,36 @@ void Dotenv::ParseContent(const std::string_view input) {
       continue;
     }
 
+    // If the content starts with `[` we're most likely entering
+    // a section (e.g. `[section]`)
+    if (content.front() == '[') {
+      auto closing_bracket_idx = content.find_first_of(']');
+      if (closing_bracket_idx != std::string_view::npos) {
+        // We've indeed entered a new section
+        auto quote_idx = content.find_first_of('"');
+        if (quote_idx != std::string_view::npos &&
+            quote_idx < closing_bracket_idx) {
+          // There is a section alias that we want to ignore
+          // (e.g. `[my_section "Section Description"]`)
+          current_section = content.substr(1, quote_idx - 1);
+        } else {
+          current_section = content.substr(1, closing_bracket_idx - 1);
+        }
+        current_section = trim_spaces(current_section);
+
+        content.remove_prefix(closing_bracket_idx + 1);
+        // After processing the section we remove everything after the closing
+        // bracket, this means that if the user put something after the section
+        // that will be completely ignored this makes sense for comments, but
+        // for other content we might want to consider throwing a syntax error
+        // or something like that in the future
+        auto newline_idx = content.find_first_of('\n');
+        if (newline_idx != std::string_view::npos) {
+          content.remove_prefix(newline_idx + 1);
+        }
+      }
+    }
+
     // Find the next equals sign or newline in a single pass.
     // This optimizes the search by avoiding multiple iterations.
     auto equal_or_newline = content.find_first_of("=\n");
@@ -176,7 +267,7 @@ void Dotenv::ParseContent(const std::string_view input) {
 
     // If the value is not present (e.g. KEY=) set it to an empty string
     if (content.empty() || content.front() == '\n') {
-      store_.insert_or_assign(std::string(key), "");
+      maybe_insert_or_assign_to_store(std::string(key), "");
       continue;
     }
 
@@ -201,7 +292,7 @@ void Dotenv::ParseContent(const std::string_view input) {
     if (content.empty()) {
       // In case the last line is a single key without value
       // Example: KEY= (without a newline at the EOF)
-      store_.insert_or_assign(std::string(key), "");
+      maybe_insert_or_assign_to_store(std::string(key), "");
       break;
     }
 
@@ -221,7 +312,7 @@ void Dotenv::ParseContent(const std::string_view input) {
           pos += 1;
         }
 
-        store_.insert_or_assign(std::string(key), multi_line_value);
+        maybe_insert_or_assign_to_store(std::string(key), multi_line_value);
         auto newline = content.find('\n', closing_quote + 1);
         if (newline != std::string_view::npos) {
           content.remove_prefix(newline + 1);
@@ -248,18 +339,18 @@ void Dotenv::ParseContent(const std::string_view input) {
         auto newline = content.find('\n');
         if (newline != std::string_view::npos) {
           value = content.substr(0, newline);
-          store_.insert_or_assign(std::string(key), value);
+          maybe_insert_or_assign_to_store(std::string(key), value);
           content.remove_prefix(newline + 1);
         } else {
           // No newline - take rest of content
           value = content;
-          store_.insert_or_assign(std::string(key), value);
+          maybe_insert_or_assign_to_store(std::string(key), value);
           break;
         }
       } else {
         // Found closing quote - take content between quotes
         value = content.substr(1, closing_quote - 1);
-        store_.insert_or_assign(std::string(key), value);
+        maybe_insert_or_assign_to_store(std::string(key), value);
         auto newline = content.find('\n', closing_quote + 1);
         if (newline != std::string_view::npos) {
           // Use +1 to discard the '\n' itself => next line
@@ -285,7 +376,7 @@ void Dotenv::ParseContent(const std::string_view input) {
           value = value.substr(0, hash_character);
         }
         value = trim_spaces(value);
-        store_.insert_or_assign(std::string(key), std::string(value));
+        maybe_insert_or_assign_to_store(std::string(key), std::string(value));
         content.remove_prefix(newline + 1);
       } else {
         // Last line without newline
@@ -294,7 +385,7 @@ void Dotenv::ParseContent(const std::string_view input) {
         if (hash_char != std::string_view::npos) {
           value = content.substr(0, hash_char);
         }
-        store_.insert_or_assign(std::string(key), trim_spaces(value));
+        maybe_insert_or_assign_to_store(std::string(key), trim_spaces(value));
         content = {};
       }
     }
@@ -303,7 +394,8 @@ void Dotenv::ParseContent(const std::string_view input) {
   }
 }
 
-Dotenv::ParseResult Dotenv::ParsePath(const std::string_view path) {
+Dotenv::ParseResult Dotenv::ParsePath(const std::string_view path,
+                                      const std::set<std::string> sections) {
   uv_fs_t req;
   auto defer_req_cleanup = OnScopeLeave([&req]() { uv_fs_req_cleanup(&req); });
 
@@ -337,7 +429,7 @@ Dotenv::ParseResult Dotenv::ParsePath(const std::string_view path) {
     result.append(buf.base, r);
   }
 
-  ParseContent(result);
+  ParseContent(result, sections);
   return ParseResult::Valid;
 }
 
diff --git a/src/node_dotenv.h b/src/node_dotenv.h
index 689c763907c26a..ecb696d98f9411 100644
--- a/src/node_dotenv.h
+++ b/src/node_dotenv.h
@@ -7,6 +7,7 @@
 #include "v8.h"
 
 #include <map>
+#include <set>
 
 namespace node {
 
@@ -16,6 +17,7 @@ class Dotenv {
   struct env_file_data {
     std::string path;
     bool is_optional;
+    std::set<std::string> sections;
   };
 
   Dotenv() = default;
@@ -25,8 +27,10 @@ class Dotenv {
   Dotenv& operator=(const Dotenv& d) = delete;
   ~Dotenv() = default;
 
-  void ParseContent(const std::string_view content);
-  ParseResult ParsePath(const std::string_view path);
+  void ParseContent(const std::string_view content,
+                    const std::set<std::string> sections);
+  ParseResult ParsePath(const std::string_view path,
+                        const std::set<std::string>);
   void AssignNodeOptionsIfAvailable(std::string* node_options) const;
   v8::Maybe<void> SetEnvironment(Environment* env);
   v8::MaybeLocal<v8::Object> ToObject(Environment* env) const;
diff --git a/src/node_process_methods.cc b/src/node_process_methods.cc
index 9dd936c8ba9dcf..a2561cfc916df2 100644
--- a/src/node_process_methods.cc
+++ b/src/node_process_methods.cc
@@ -590,21 +590,42 @@ static void Execve(const FunctionCallbackInfo<Value>& args) {
 }
 #endif
 
+struct IterateSectionsData {
+  Isolate* isolate;
+  std::set<std::string>* sections;
+};
+
+static v8::Array::CallbackResult IterateSectionsCallback(uint32_t index,
+                                                         Local<Value> element,
+                                                         void* data) {
+  auto* iteration_data = static_cast<IterateSectionsData*>(data);
+  CHECK(element->IsString());
+  BufferValue string(iteration_data->isolate, element);
+  iteration_data->sections->insert(string.ToString());
+  return v8::Array::CallbackResult::kContinue;
+}
+
 static void LoadEnvFile(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  std::string path = ".env";
-  if (args.Length() == 1) {
-    BufferValue path_value(args.GetIsolate(), args[0]);
-    ToNamespacedPath(env, &path_value);
-    path = path_value.ToString();
-  }
+  CHECK_EQ(args.Length(), 2);  // path, sections
+
+  BufferValue path_value(args.GetIsolate(), args[0]);
+  ToNamespacedPath(env, &path_value);
+  auto path = path_value.ToString();
+
+  CHECK(args[1]->IsArray());
+  Local<Array> args_sections = args[1].As<Array>();
+  std::set<std::string> sections = {};
+
+  IterateSectionsData data{env->isolate(), &sections};
+  args_sections->Iterate(env->context(), IterateSectionsCallback, &data);
 
   THROW_IF_INSUFFICIENT_PERMISSIONS(
       env, permission::PermissionScope::kFileSystemRead, path);
 
   Dotenv dotenv{};
 
-  switch (dotenv.ParsePath(path)) {
+  switch (dotenv.ParsePath(path, sections)) {
     case dotenv.ParseResult::Valid: {
       USE(dotenv.SetEnvironment(env));
       break;
diff --git a/src/node_util.cc b/src/node_util.cc
index 85ef1c205e0d50..874abfc2ee5a4e 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -3,6 +3,7 @@
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "util-inl.h"
+#include "v8-container.h"
 #include "v8-fast-api-calls.h"
 
 namespace node {
@@ -237,13 +238,36 @@ static uint32_t FastGuessHandleType(Local<Value> receiver, const uint32_t fd) {
 
 CFunction fast_guess_handle_type_(CFunction::Make(FastGuessHandleType));
 
+struct IterateSectionsData {
+  Isolate* isolate;
+  std::set<std::string>* sections;
+};
+
+static v8::Array::CallbackResult IterateSectionsCallback(uint32_t index,
+                                                         Local<Value> element,
+                                                         void* data) {
+  auto* iteration_data = static_cast<IterateSectionsData*>(data);
+  CHECK(element->IsString());
+  BufferValue string(iteration_data->isolate, element);
+  iteration_data->sections->insert(string.ToString());
+  return v8::Array::CallbackResult::kContinue;
+}
+
 static void ParseEnv(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  CHECK_EQ(args.Length(), 1);  // content
+  CHECK_EQ(args.Length(), 2);  // content, sections
   CHECK(args[0]->IsString());
   Utf8Value content(env->isolate(), args[0]);
   Dotenv dotenv{};
-  dotenv.ParseContent(content.ToStringView());
+  CHECK(args[1]->IsArray());
+  Local<Array> args_sections = args[1].As<Array>();
+  std::set<std::string> sections = {};
+
+  IterateSectionsData data{env->isolate(), &sections};
+  args_sections->Iterate(env->context(), IterateSectionsCallback, &data);
+
+  dotenv.ParseContent(content.ToStringView(), sections);
+
   Local<Object> obj;
   if (dotenv.ToObject(env).ToLocal(&obj)) {
     args.GetReturnValue().Set(obj);
diff --git a/test/fixtures/dotenv/sections.env b/test/fixtures/dotenv/sections.env
new file mode 100644
index 00000000000000..bb7fd4da8092a7
--- /dev/null
+++ b/test/fixtures/dotenv/sections.env
@@ -0,0 +1,16 @@
+_ENV_TEST_A = 'A (top-level)'
+_ENV_TEST_B = 'B (top-level)'
+
+[dev]
+_ENV_TEST_A = 'A (development)'
+_ENV_TEST_C = 'C (development)'
+
+[prod]
+_ENV_TEST_A = 'A (production)'
+_ENV_TEST_D = 'D (production)'
+
+[x.y.z "an additional section"]
+_ENV_TEST_X = 'Y_Z'
+
+[with_comment] # this is a section that is followed by a comment
+_ENV_TEST_COMMENT = 'this section has a comment'
diff --git a/test/parallel/test-dotenv-sections.js b/test/parallel/test-dotenv-sections.js
new file mode 100644
index 00000000000000..f0cbda4b0c8a72
--- /dev/null
+++ b/test/parallel/test-dotenv-sections.js
@@ -0,0 +1,66 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const { describe, it } = require('node:test');
+
+const envFilePath = '../fixtures/dotenv/sections.env';
+
+async function getProcessEnvTestEntries(envFileArg) {
+  const code = `
+      console.log(
+        JSON.stringify(
+          Object.fromEntries(Object.entries(process.env).filter(([key]) => key.startsWith('_ENV_TEST_')))
+        )
+      );
+    `.trim();
+  const child = await common.spawnPromisified(
+    process.execPath,
+    [ `--env-file=${envFileArg}`, '--eval', code ],
+    { cwd: __dirname },
+  );
+  assert.strictEqual(child.code, 0);
+  return JSON.parse(child.stdout.replace(/\n/g, ''));
+}
+
+describe('.env sections support', () => {
+  it('should only get the top-level variables if a section is not specified', async () => {
+    const env = await getProcessEnvTestEntries(envFilePath);
+    assert.deepStrictEqual(env, {
+      _ENV_TEST_A: 'A (top-level)',
+      _ENV_TEST_B: 'B (top-level)',
+    });
+  });
+
+  it('should get section specific variables if a section is specified', async () => {
+    const env = await getProcessEnvTestEntries(`${envFilePath}#dev`);
+    assert.strictEqual(env._ENV_TEST_A, 'A (development)');
+    assert.strictEqual(env._ENV_TEST_C, 'C (development)');
+    assert(!('_ENV_TEST_D' in env), 'the _ENV_TEST_D should not be present for the dev section');
+  });
+
+  it('should allow top-level variables to be inherited if not specified in a section', async () => {
+    const env = await getProcessEnvTestEntries(`${envFilePath}#dev`);
+    assert.strictEqual(env._ENV_TEST_B, 'B (top-level)');
+  });
+
+  it('should allow multiple sections to be specified (values are overridden as per the file order)', async () => {
+    const env = await getProcessEnvTestEntries(`${envFilePath}#dev#prod`);
+    assert.deepStrictEqual(env, {
+      _ENV_TEST_A: 'A (production)',
+      _ENV_TEST_B: 'B (top-level)',
+      _ENV_TEST_C: 'C (development)',
+      _ENV_TEST_D: 'D (production)'
+    });
+  });
+
+  it('should ignore section aliases', async () => {
+    const env = await getProcessEnvTestEntries(`${envFilePath}#x.y.z`);
+    assert.strictEqual(env._ENV_TEST_X, 'Y_Z');
+  });
+
+  it('should allow comments to be present after the section declaration', async () => {
+    const env = await getProcessEnvTestEntries(`${envFilePath}#with_comment`);
+    assert.strictEqual(env._ENV_TEST_COMMENT, 'this section has a comment');
+  });
+});
diff --git a/test/parallel/test-process-load-env-file-sections.js b/test/parallel/test-process-load-env-file-sections.js
new file mode 100644
index 00000000000000..da7e5eecd0f85e
--- /dev/null
+++ b/test/parallel/test-process-load-env-file-sections.js
@@ -0,0 +1,64 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const { describe, it } = require('node:test');
+
+const envFilePath = '../fixtures/dotenv/sections.env';
+
+async function getProcessEnvTestEntries(sections) {
+  const code = `
+      process.loadEnvFile('${envFilePath}', { sections: ${JSON.stringify(sections)} });
+      console.log(
+        JSON.stringify(
+          Object.fromEntries(Object.entries(process.env).filter(([key]) => key.startsWith('_ENV_TEST_')))
+        )
+      );
+    `.trim();
+  const child = await common.spawnPromisified(
+    process.execPath,
+    ['--eval', code],
+    { cwd: __dirname },
+  );
+  assert.strictEqual(child.code, 0);
+  return JSON.parse(child.stdout.replace(/\n/g, ''));
+}
+
+describe('process.loadEnvFile() with sections', () => {
+  it('should allow the selection of sections', async () => {
+    const env = await getProcessEnvTestEntries(['dev']);
+    assert.deepStrictEqual(env, {
+      _ENV_TEST_A: 'A (development)',
+      _ENV_TEST_B: 'B (top-level)',
+      _ENV_TEST_C: 'C (development)',
+    });
+  });
+
+  it('should ignore sections when they are omitted', async () => {
+    const env = await getProcessEnvTestEntries([]);
+    assert.deepStrictEqual(env, {
+      _ENV_TEST_A: 'A (top-level)',
+      _ENV_TEST_B: 'B (top-level)',
+    });
+  });
+
+  it('should throw an ERR_INVALID_ARG_TYPE if a non-array sections value is passed', async () => {
+    let error;
+    try {
+      process.loadEnvFile(envFilePath, { sections: () => console.log('this is invalid') });
+    } catch (e) {
+      error = e;
+    }
+    assert.strictEqual(error.code, 'ERR_INVALID_ARG_TYPE');
+  });
+
+  it('should throw an ERR_INVALID_ARG_TYPE if an array not containing all strings is passed', async () => {
+    let error;
+    try {
+      process.loadEnvFile(envFilePath, { sections: ['a', 'b', 1, () => 2] });
+    } catch (e) {
+      error = e;
+    }
+    assert.strictEqual(error.code, 'ERR_INVALID_ARG_TYPE');
+  });
+});
diff --git a/test/parallel/test-util-parse-env-sections.js b/test/parallel/test-util-parse-env-sections.js
new file mode 100644
index 00000000000000..24ca27a2a7e5b0
--- /dev/null
+++ b/test/parallel/test-util-parse-env-sections.js
@@ -0,0 +1,51 @@
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+const util = require('node:util');
+
+const content = `
+  X = x
+  Y = y
+
+  [section-a]
+  X = x_a
+
+  [section-b]
+  Y = y_b
+  Z = z_b
+`;
+
+// Test that sections can be normally selected
+{
+  const parsedEnv = util.parseEnv(content, { sections: ['section-b'] });
+  assert.deepStrictEqual(parsedEnv, { X: 'x', Y: 'y_b', Z: 'z_b' });
+}
+
+// Test that sections are ignored when omitted
+{
+  const parsedEnv = util.parseEnv(content);
+  assert.deepStrictEqual(parsedEnv, { X: 'x', Y: 'y' });
+}
+
+// Test that passing an non-array sections value causes an ERR_INVALID_ARG_TYPE error to be thrown
+{
+  let error;
+  try {
+    util.parseEnv(content, { sections: () => console.log('this is invalid') });
+  } catch (e) {
+    error = e;
+  }
+  assert.strictEqual(error.code, 'ERR_INVALID_ARG_TYPE');
+}
+
+// Test that passing an array not containing all strings an ERR_INVALID_ARG_TYPE error to be thrown
+{
+  let error;
+  try {
+    util.parseEnv(content, { sections: ['a', 'b', 1, () => 2] });
+  } catch (e) {
+    error = e;
+  }
+  assert.strictEqual(error.code, 'ERR_INVALID_ARG_TYPE');
+}