diff --git a/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java b/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java
new file mode 100644
index 0000000..e0a8fe6
--- /dev/null
+++ b/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java
@@ -0,0 +1,567 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration.hocon;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import com.typesafe.config.ConfigFactory;
+import com.typesafe.config.ConfigRenderOptions;
+import com.typesafe.config.ConfigValue;
+import org.apache.ignite.configuration.annotation.Config;
+import org.apache.ignite.configuration.annotation.ConfigurationRoot;
+import org.apache.ignite.configuration.annotation.ConfigurationType;
+import org.apache.ignite.configuration.annotation.NamedConfigValue;
+import org.apache.ignite.configuration.annotation.Value;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.apache.ignite.internal.configuration.hocon.HoconConverter.hoconSource;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Tests for the {@link HoconConverter}.
+ */
+public class HoconConverterTest {
+    /** */
+    @ConfigurationRoot(rootName = "root", type = ConfigurationType.LOCAL)
+    public static class HoconRootConfigurationSchema {
+        /** */
+        @NamedConfigValue(syntheticKeyName = "a")
+        public HoconArraysConfigurationSchema arraysList;
+
+        /** */
+        @NamedConfigValue(syntheticKeyName = "p")
+        public HoconPrimitivesConfigurationSchema primitivesList;
+    }
+
+    /**
+     * Configuration schema for testing the support of arrays of primitives.
+     */
+    @Config
+    public static class HoconArraysConfigurationSchema {
+        /** */
+        @Value(hasDefault = true)
+        public boolean[] booleans = {false};
+
+        /** */
+        @Value(hasDefault = true)
+        public byte[] bytes = {0};
+
+        /** */
+        @Value(hasDefault = true)
+        public short[] shorts = {0};
+
+        /** */
+        @Value(hasDefault = true)
+        public int[] ints = {0};
+
+        /** */
+        @Value(hasDefault = true)
+        public long[] longs = {0L};
+
+        /** */
+        @Value(hasDefault = true)
+        public char[] chars = {0};
+
+        /** */
+        @Value(hasDefault = true)
+        public float[] floats = {0};
+
+        /** */
+        @Value(hasDefault = true)
+        public double[] doubles = {0};
+
+        /** */
+        @Value(hasDefault = true)
+        public String[] strings = {""};
+    }
+
+    /**
+     * Configuration schema for testing the support of primitives.
+     */
+    @Config
+    public static class HoconPrimitivesConfigurationSchema {
+        /** */
+        @Value(hasDefault = true)
+        public boolean booleanVal = false;
+
+        /** */
+        @Value(hasDefault = true)
+        public byte byteVal = 0;
+
+        /** */
+        @Value(hasDefault = true)
+        public short shortVal = 0;
+
+        /** */
+        @Value(hasDefault = true)
+        public int intVal = 0;
+
+        /** */
+        @Value(hasDefault = true)
+        public long longVal = 0L;
+
+        /** */
+        @Value(hasDefault = true)
+        public char charVal = 0;
+
+        /** */
+        @Value(hasDefault = true)
+        public float floatVal = 0;
+
+        /** */
+        @Value(hasDefault = true)
+        public double doubleVal = 0;
+
+        /** */
+        @Value(hasDefault = true)
+        public String stringVal = "";
+    }
+
+    /** */
+    private static ConfigurationRegistry registry;
+
+    /** */
+    private static HoconRootConfiguration configuration;
+
+    /** */
+    @BeforeAll
+    public static void beforeAll() {
+        registry = new ConfigurationRegistry(
+            Collections.singletonList(HoconRootConfiguration.KEY),
+            Collections.emptyMap(),
+            Collections.singletonList(new TestConfigurationStorage())
+        );
+
+        configuration = registry.getConfiguration(HoconRootConfiguration.KEY);
+    }
+
+    /** */
+    @AfterAll
+    public static void after() {
+        registry.stop();
+
+        registry = null;
+
+        configuration = null;
+    }
+
+    /** */
+    @BeforeEach
+    public void before() throws Exception {
+        configuration.change(cfg -> cfg
+            .changePrimitivesList(list -> list.namedListKeys().forEach(list::delete))
+            .changeArraysList(list -> list.namedListKeys().forEach(list::delete))
+        ).get(1, SECONDS);
+    }
+
+    /** */
+    @Test
+    public void toHoconBasic() {
+        assertEquals("root{arraysList=[],primitivesList=[]}", asHoconStr(List.of()));
+
+        assertEquals("arraysList=[],primitivesList=[]", asHoconStr(List.of("root")));
+
+        assertEquals("[]", asHoconStr(List.of("root", "arraysList")));
+
+        assertThrowsIllegalArgException(
+            () -> HoconConverter.represent(registry, List.of("doot")),
+            "Configuration 'doot' is not found"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> HoconConverter.represent(registry, List.of("root", "x")),
+            "Configuration 'root.x' is not found"
+        );
+
+        assertEquals("null", asHoconStr(List.of("root", "primitivesList", "foo")));
+    }
+
+    /**
+     * Tests that the {@code HoconConverter} supports serialization of Strings and primitives.
+     */
+    @Test
+    public void testHoconPrimitivesSerialization() throws Exception {
+        configuration.change(cfg -> cfg
+            .changePrimitivesList(primitivesList -> primitivesList
+                .create("name", primitives -> {})
+            )
+        ).get(1, SECONDS);
+
+        var basePath = List.of("root", "primitivesList", "name");
+
+        assertEquals(
+            "booleanVal=false,byteVal=0,charVal=\"\\u0000\",doubleVal=0.0,floatVal=0,intVal=0,longVal=0,shortVal=0,stringVal=\"\"",
+            asHoconStr(basePath)
+        );
+
+        assertEquals("false", asHoconStr(basePath, "booleanVal"));
+        assertEquals("0", asHoconStr(basePath, "byteVal"));
+        assertEquals("0", asHoconStr(basePath, "shortVal"));
+        assertEquals("0", asHoconStr(basePath, "intVal"));
+        assertEquals("0", asHoconStr(basePath, "longVal"));
+        assertEquals("\"\\u0000\"", asHoconStr(basePath, "charVal"));
+        assertEquals("0", asHoconStr(basePath, "floatVal"));
+        assertEquals("0.0", asHoconStr(basePath, "doubleVal"));
+        assertEquals("\"\"", asHoconStr(basePath, "stringVal"));
+    }
+
+    /**
+     * Tests that the {@code HoconConverter} supports serialization of arrays of Strings and primitives.
+     */
+    @Test
+    public void testHoconArraysSerialization() throws Exception {
+        configuration.change(cfg -> cfg
+            .changeArraysList(arraysList -> arraysList
+                .create("name", arrays -> {})
+            )
+        ).get(1, SECONDS);
+
+        var basePath = List.of("root", "arraysList", "name");
+
+        assertEquals(
+            "booleans=[false],bytes=[0],chars=[\"\\u0000\"],doubles=[0.0],floats=[0],ints=[0],longs=[0],shorts=[0],strings=[\"\"]",
+            asHoconStr(basePath)
+        );
+
+        assertEquals("[false]", asHoconStr(basePath, "booleans"));
+        assertEquals("[0]", asHoconStr(basePath, "bytes"));
+        assertEquals("[0]", asHoconStr(basePath, "shorts"));
+        assertEquals("[0]", asHoconStr(basePath, "ints"));
+        assertEquals("[0]", asHoconStr(basePath, "longs"));
+        assertEquals("[\"\\u0000\"]", asHoconStr(basePath, "chars"));
+        assertEquals("[0]", asHoconStr(basePath, "floats"));
+        assertEquals("[0.0]", asHoconStr(basePath, "doubles"));
+        assertEquals("[\"\"]", asHoconStr(basePath, "strings"));
+    }
+
+    /**
+     * Retrieves the HOCON configuration located at the given path.
+     */
+    private String asHoconStr(List<String> basePath, String... path) {
+        List<String> fullPath = Stream.concat(basePath.stream(), Arrays.stream(path)).collect(Collectors.toList());
+
+        ConfigValue hoconCfg = HoconConverter.represent(registry, fullPath);
+
+        return hoconCfg.render(ConfigRenderOptions.concise().setJson(false));
+    }
+
+    /** */
+    @Test
+    public void fromHoconBasic() {
+        // Wrong names:
+        assertThrowsIllegalArgException(
+            () -> change("doot : {}"),
+            "'doot' configuration root doesn't exist"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.foo : {}"),
+            "'root' configuration doesn't have the 'foo' sub-configuration"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.x = 1"),
+            "'root.arraysList.name' configuration doesn't have the 'x' sub-configuration"
+        );
+
+        // Wrong node types:
+        assertThrowsIllegalArgException(
+            () -> change("root = foo"),
+            "'root' is expected to be a composite configuration node, not a single value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList = foo"),
+            "'root.arraysList' is expected to be a composite configuration node, not a single value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name = foo"),
+            "'root.arraysList.name' is expected to be a composite configuration node, not a single value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.ints = {}"),
+            "'int[]' is expected as a type for the 'root.arraysList.name.ints' configuration value"
+        );
+
+        // Wrong ordered named list syntax:
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList = [1]"),
+            "'root.arraysList[0]' is expected to be a composite configuration node, not a single value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList = [{}]"),
+            "'root.arraysList[0].a' configuration value is mandatory and must be a String"
+        );
+    }
+
+    /**
+     * Tests that the {@code HoconConverter} supports deserialization of Strings and primitives.
+     */
+    @Test
+    public void testHoconPrimitivesDeserialization() throws Throwable {
+        change("root.primitivesList = [{p = name}]");
+
+        HoconPrimitivesConfiguration primitives = configuration.primitivesList().get("name");
+        assertNotNull(primitives);
+
+        change("root.primitivesList.name.booleanVal = true");
+        assertThat(primitives.booleanVal().value(), is(true));
+
+        change("root.primitivesList.name.byteVal = 123");
+        assertThat(primitives.byteVal().value(), is((byte)123));
+
+        change("root.primitivesList.name.shortVal = 12345");
+        assertThat(primitives.shortVal().value(), is((short)12345));
+
+        change("root.primitivesList.name.intVal = 12345");
+        assertThat(primitives.intVal().value(), is(12345));
+
+        change("root.primitivesList.name.longVal = 12345678900");
+        assertThat(primitives.longVal().value(), is(12345678900L));
+
+        change("root.primitivesList.name.charVal = p");
+        assertThat(primitives.charVal().value(), is('p'));
+
+        change("root.primitivesList.name.floatVal = 2.5");
+        assertThat(primitives.floatVal().value(), is(2.5f));
+
+        change("root.primitivesList.name.doubleVal = 2.5");
+        assertThat(primitives.doubleVal().value(), is(2.5d));
+
+        change("root.primitivesList.name.stringVal = foo");
+        assertThat(primitives.stringVal().value(), is("foo"));
+    }
+
+    /**
+     * Tests deserialization errors that can happen during the deserialization of primitives.
+     */
+    @Test
+    public void testInvalidHoconPrimitivesDeserialization() {
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.booleanVal = \"true\""),
+            "'boolean' is expected as a type for the 'root.primitivesList.name.booleanVal' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.byteVal = 290"),
+            "Value '290' of 'root.primitivesList.name.byteVal' is out of its declared bounds"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.byteVal = false"),
+            "'byte' is expected as a type for the 'root.primitivesList.name.byteVal' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.shortVal = 12345678900"),
+            "Value '12345678900' of 'root.primitivesList.name.shortVal' is out of its declared bounds"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.shortVal = false"),
+            "'short' is expected as a type for the 'root.primitivesList.name.shortVal' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.intVal = 12345678900"),
+            "Value '12345678900' of 'root.primitivesList.name.intVal' is out of its declared bounds"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.intVal = false"),
+            "'int' is expected as a type for the 'root.primitivesList.name.intVal' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.longVal = false"),
+            "'long' is expected as a type for the 'root.primitivesList.name.longVal' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.charVal = 10"),
+            "'char' is expected as a type for the 'root.primitivesList.name.charVal' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.floatVal = false"),
+            "'float' is expected as a type for the 'root.primitivesList.name.floatVal' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.doubleVal = []"),
+            "'double' is expected as a type for the 'root.primitivesList.name.doubleVal' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.primitivesList.name.stringVal = 10"),
+            "'String' is expected as a type for the 'root.primitivesList.name.stringVal' configuration value"
+        );
+    }
+
+    /**
+     * Tests that the {@code HoconConverter} supports deserialization of arrays of Strings and primitives.
+     */
+    @Test
+    public void testHoconArraysDeserialization() throws Throwable {
+        change("root.arraysList = [{a = name}]");
+
+        HoconArraysConfiguration arrays = configuration.arraysList().get("name");
+        assertNotNull(arrays);
+
+        change("root.arraysList.name.booleans = [true]");
+        assertThat(arrays.booleans().value(), is(new boolean[] {true}));
+
+        change("root.arraysList.name.bytes = [123]");
+        assertThat(arrays.bytes().value(), is(new byte[] {123}));
+
+        change("root.arraysList.name.shorts = [123]");
+        assertThat(arrays.shorts().value(), is(new short[] {123}));
+
+        change("root.arraysList.name.ints = [12345]");
+        assertThat(arrays.ints().value(), is(new int[] {12345}));
+
+        change("root.arraysList.name.longs = [12345678900]");
+        assertThat(arrays.longs().value(), is(new long[] {12345678900L}));
+
+        change("root.arraysList.name.chars = [p]");
+        assertThat(arrays.chars().value(), is(new char[] {'p'}));
+
+        change("root.arraysList.name.floats = [2.5]");
+        assertThat(arrays.floats().value(), is(new float[] {2.5f}));
+
+        change("root.arraysList.name.doubles = [2.5]");
+        assertThat(arrays.doubles().value(), is(new double[] {2.5d}));
+
+        change("root.arraysList.name.strings = [foo]");
+        assertThat(arrays.strings().value(), is(new String[] {"foo"}));
+    }
+
+    /**
+     * Tests deserialization errors that can happen during the deserialization of arrays of primitives.
+     */
+    @Test
+    public void testInvalidHoconArraysDeserialization() {
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.booleans = true"),
+            "'boolean[]' is expected as a type for the 'root.arraysList.name.booleans' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.booleans = [{}]"),
+            "'boolean' is expected as a type for the 'root.arraysList.name.booleans[0]' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.bytes = [123, 290]"),
+            "Value '290' of 'root.arraysList.name.bytes[1]' is out of its declared bounds"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.bytes = false"),
+            "'byte[]' is expected as a type for the 'root.arraysList.name.bytes' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.shorts = [12345678900]"),
+            "Value '12345678900' of 'root.arraysList.name.shorts[0]' is out of its declared bounds"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.shorts = [123, false]"),
+            "'short' is expected as a type for the 'root.arraysList.name.shorts[1]' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.ints = [5, 12345678900]"),
+            "Value '12345678900' of 'root.arraysList.name.ints[1]' is out of its declared bounds"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.ints = false"),
+            "'int[]' is expected as a type for the 'root.arraysList.name.ints' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.longs = [foo]"),
+            "'long' is expected as a type for the 'root.arraysList.name.longs[0]' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.chars = 10"),
+            "'char[]' is expected as a type for the 'root.arraysList.name.chars' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.chars = [abc]"),
+            "'char' is expected as a type for the 'root.arraysList.name.chars[0]' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.floats = [1.2, foo]"),
+            "'float' is expected as a type for the 'root.arraysList.name.floats[1]' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.doubles = foo"),
+            "'double[]' is expected as a type for the 'root.arraysList.name.doubles' configuration value"
+        );
+
+        assertThrowsIllegalArgException(
+            () -> change("root.arraysList.name.strings = 10"),
+            "'String[]' is expected as a type for the 'root.arraysList.name.strings' configuration value"
+        );
+    }
+
+    /**
+     * Updates the configuration using the provided HOCON string.
+     */
+    private void change(String hocon) throws Throwable {
+        try {
+            registry.change(hoconSource(ConfigFactory.parseString(hocon).root()), null).get(1, SECONDS);
+        }
+        catch (ExecutionException e) {
+            throw e.getCause();
+        }
+    }
+
+    /** */
+    private static void assertThrowsIllegalArgException(Executable executable, String msg) {
+        IllegalArgumentException e = assertThrows(IllegalArgumentException.class, executable);
+
+        assertThat(e.getMessage(), containsString(msg));
+    }
+}
diff --git a/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/json/JsonConverterTest.java b/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/json/JsonConverterTest.java
index 51ee93a..deeb07c 100644
--- a/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/json/JsonConverterTest.java
+++ b/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/json/JsonConverterTest.java
@@ -31,6 +31,7 @@
 import org.apache.ignite.configuration.annotation.NamedConfigValue;
 import org.apache.ignite.configuration.annotation.Value;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
diff --git a/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/json/TestConfigurationStorage.java b/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/json/TestConfigurationStorage.java
deleted file mode 100644
index 4b916d6..0000000
--- a/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/json/TestConfigurationStorage.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.configuration.json;
-
-import java.io.Serializable;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import org.apache.ignite.configuration.annotation.ConfigurationType;
-import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
-import org.apache.ignite.internal.configuration.storage.ConfigurationStorageListener;
-import org.apache.ignite.internal.configuration.storage.Data;
-import org.apache.ignite.internal.configuration.storage.StorageException;
-
-/** */
-class TestConfigurationStorage implements ConfigurationStorage {
-    /** */
-    private final Set<ConfigurationStorageListener> listeners = new HashSet<>();
-
-    /** {@inheritDoc} */
-    @Override public Data readAll() throws StorageException {
-        return new Data(Collections.emptyMap(), 0);
-    }
-
-    /** {@inheritDoc} */
-    @Override public CompletableFuture<Boolean> write(Map<String, Serializable> newValues, long version) {
-        for (ConfigurationStorageListener listener : listeners)
-            listener.onEntriesChanged(new Data(newValues, version + 1));
-
-        return CompletableFuture.completedFuture(true);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void registerConfigurationListener(ConfigurationStorageListener listener) {
-        listeners.add(listener);
-    }
-
-    /** {@inheritDoc} */
-    @Override public void notifyApplied(long storageRevision) {
-    }
-
-    /** {@inheritDoc} */
-    @Override public ConfigurationType type() {
-        return ConfigurationType.LOCAL;
-    }
-}
diff --git a/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/tree/TraversableTreeNodeTest.java b/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/tree/TraversableTreeNodeTest.java
index 1894f6a..31a42a7 100644
--- a/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/tree/TraversableTreeNodeTest.java
+++ b/modules/configuration-annotation-processor/src/test/java/org/apache/ignite/internal/configuration/tree/TraversableTreeNodeTest.java
@@ -41,6 +41,7 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNotSame;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 /** */
@@ -197,8 +198,14 @@
 
         assertNotNull(elementNode);
 
+        assertSame(elementNode, elementsNode.get(0));
+
         assertNull(elementNode.strCfg());
 
+        assertThrows(IndexOutOfBoundsException.class, () -> elementsNode.get(-1));
+
+        assertThrows(IndexOutOfBoundsException.class, () -> elementsNode.get(1));
+
         elementsNode.createOrUpdate("keyPut", element -> element.changeStrCfg("val"));
 
         // Assert that consecutive put methods create new object every time.
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/NamedListChange.java b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/NamedListChange.java
index 3371295..ba42132 100644
--- a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/NamedListChange.java
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/NamedListChange.java
@@ -88,7 +88,8 @@
      * @return {@code this} for chaining.
      *
      * @throws NullPointerException If key is null.
-     * @throws IllegalArgumentException If {@link #createOrUpdate(String, Consumer)} has been invoked with the same key previously.
+     * @throws IllegalArgumentException If {@link #createOrUpdate(String, Consumer)} has been invoked with the same key
+     *      previously.
      */
     NamedListChange<Change> delete(String key);
 }
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/NamedListView.java b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/NamedListView.java
index 60d8e9c..c422cb3 100644
--- a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/NamedListView.java
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/NamedListView.java
@@ -41,6 +41,15 @@
     View get(String key);
 
     /**
+     * Returns value located at the specified index.
+     *
+     * @param index Value index.
+     * @return Requested value.
+     * @throws IndexOutOfBoundsException If index is out of bounds.
+     */
+    View get(int index) throws IndexOutOfBoundsException;
+
+    /**
      * Returns the number of elements in this list.
      *
      * @return Number of elements.
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/annotation/NamedConfigValue.java b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/annotation/NamedConfigValue.java
index b5752b2..1746135 100644
--- a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/annotation/NamedConfigValue.java
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/annotation/NamedConfigValue.java
@@ -41,8 +41,30 @@
  * }
  * </code></pre>
  */
-@Target({ FIELD })
+@Target(FIELD)
 @Retention(RUNTIME)
 @Documented
 public @interface NamedConfigValue {
+    /**
+     * Key that can be used in HOCON configuration syntax to declare named list with fixed order.
+     * <pre><code>
+     * {
+     *     root : {
+     *         namedList : [
+     *             {
+     *                 syntheticKey : Element1,
+     *                 someValue = Value1
+     *             },
+     *             {
+     *                 syntheticKey : Element2,
+     *                 someValue = Value2
+     *             }
+     *         ]
+     *     }
+     * }
+     * </code></pre>
+     *
+     * @return Name for the synthetic key.
+     */
+    String syntheticKeyName() default "name";
 }
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/validation/Max.java b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/validation/Max.java
index 8a4f19a..70a8e47 100644
--- a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/validation/Max.java
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/validation/Max.java
@@ -25,7 +25,7 @@
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Signifies that this value has upper limit (exclusive).
+ * Signifies that this value has upper limit (inclusive).
  */
 @Target(FIELD)
 @Retention(RUNTIME)
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/validation/Min.java b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/validation/Min.java
index 54b1ac4..e5e82dc 100644
--- a/modules/configuration-api/src/main/java/org/apache/ignite/configuration/validation/Min.java
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/configuration/validation/Min.java
@@ -25,7 +25,7 @@
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * Signifies that this value has lower limit (exclusive).
+ * Signifies that this value has lower limit (inclusive).
  */
 @Target(FIELD)
 @Retention(RUNTIME)
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationManager.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationManager.java
index 1cb81e4..9885e4a 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationManager.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationManager.java
@@ -24,14 +24,12 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
 import com.typesafe.config.ConfigFactory;
-import com.typesafe.config.ConfigRenderOptions;
+import com.typesafe.config.ConfigObject;
 import org.apache.ignite.configuration.RootKey;
 import org.apache.ignite.configuration.annotation.ConfigurationType;
 import org.apache.ignite.configuration.validation.Validator;
-import org.apache.ignite.internal.configuration.json.JsonConverter;
+import org.apache.ignite.internal.configuration.hocon.HoconConverter;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
 
 /**
@@ -84,18 +82,16 @@
 
     /**
      * Bootstrap configuration manager with customer user cfg.
+     *
      * @param hoconStr Customer configuration in hocon format.
      * @param type Configuration type.
      * @throws InterruptedException If thread is interrupted during bootstrap.
      * @throws ExecutionException If configuration update failed for some reason.
      */
     public void bootstrap(String hoconStr, ConfigurationType type) throws InterruptedException, ExecutionException {
-        // TODO https://issues.apache.org/jira/browse/IGNITE-14924 Implement HoconConfigurationSource
-        String jsonStr = ConfigFactory.parseString(hoconStr).root().render(ConfigRenderOptions.concise());
+        ConfigObject hoconCfg = ConfigFactory.parseString(hoconStr).root();
 
-        JsonObject jsonCfg = JsonParser.parseString(jsonStr).getAsJsonObject();
-
-        confRegistry.change(JsonConverter.jsonSource(jsonCfg), configurationStorages.get(type)).get();
+        confRegistry.change(HoconConverter.hoconSource(hoconCfg), configurationStorages.get(type)).get();
     }
 
     /**
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/asm/ConfigurationAsmGenerator.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/asm/ConfigurationAsmGenerator.java
index 37351a6..9848272 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/asm/ConfigurationAsmGenerator.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/asm/ConfigurationAsmGenerator.java
@@ -450,12 +450,18 @@
             if (!isNamedConfigValue(schemaField))
                 continue;
 
+            NamedConfigValue namedCfgAnnotation = schemaField.getAnnotation(NamedConfigValue.class);
+
             SchemaClassesInfo fieldClassNames = new SchemaClassesInfo(schemaField.getType());
 
-            // this.values = new NamedListNode<>(ValueNode::new);
+            // this.values = new NamedListNode<>(key, ValueNode::new);
             ctor.getBody().append(ctor.getThis().setField(
                 fieldDefs.get(schemaField.getName()),
-                newInstance(NamedListNode.class, newNamedListElementLambda(fieldClassNames.nodeClassName))
+                newInstance(
+                    NamedListNode.class,
+                    constantString(namedCfgAnnotation.syntheticKeyName()),
+                    newNamedListElementLambda(fieldClassNames.nodeClassName)
+                )
             ));
         }
 
@@ -720,15 +726,21 @@
                     )
                 );
             }
-            // this.field = src == null ? new NamedListNode(ValueNode::new) : src.descend(field = field.copy()));
+            // this.field = src == null ? new NamedListNode<>(key, ValueNode::new) : src.descend(field = field.copy()));
             else {
+                NamedConfigValue namedCfgAnnotation = schemaField.getAnnotation(NamedConfigValue.class);
+
                 String fieldNodeClassName = schemasInfo.get(schemaField.getType()).nodeClassName;
 
                 caseClause.append(new IfStatement()
                     .condition(isNull(srcVar))
                     .ifTrue(constructMtd.getThis().setField(
                         fieldDef,
-                        newInstance(NamedListNode.class, newNamedListElementLambda(fieldNodeClassName))
+                        newInstance(
+                            NamedListNode.class,
+                            constantString(namedCfgAnnotation.syntheticKeyName()),
+                            newNamedListElementLambda(fieldNodeClassName)
+                        )
                     ))
                     .ifFalse(new BytecodeBlock()
                         .append(constructMtd.getThis().setField(
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconConfigurationVisitor.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconConfigurationVisitor.java
new file mode 100644
index 0000000..7485792
--- /dev/null
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconConfigurationVisitor.java
@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration.hocon;
+
+import java.io.Serializable;
+import java.lang.reflect.Array;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import com.typesafe.config.ConfigValue;
+import org.apache.ignite.internal.configuration.tree.ConfigurationVisitor;
+import org.apache.ignite.internal.configuration.tree.InnerNode;
+import org.apache.ignite.internal.configuration.tree.NamedListNode;
+
+/**
+ * {@link ConfigurationVisitor} implementation that converts a configuration tree to a combination of {@link Map} and
+ * {@link List} objects to convert the result into HOCON {@link ConfigValue} instance.
+ */
+class HoconConfigurationVisitor implements ConfigurationVisitor<Object> {
+    /** Stack with intermediate results. Used to store values during recursive calls. */
+    private Deque<Object> deque = new ArrayDeque<>();
+
+    /** {@inheritDoc} */
+    @Override public Object visitLeafNode(String key, Serializable val) {
+        Object valObj = val;
+
+        if (val instanceof Character)
+            valObj = val.toString();
+        else if (val != null && val.getClass().isArray())
+            valObj = toListOfObjects(val);
+
+        addToParent(key, valObj);
+
+        return valObj;
+    }
+
+    /** {@inheritDoc} */
+    @Override public Object visitInnerNode(String key, InnerNode node) {
+        Map<String, Object> innerMap = new HashMap<>();
+
+        deque.push(innerMap);
+
+        node.traverseChildren(this);
+
+        deque.pop();
+
+        addToParent(key, innerMap);
+
+        return innerMap;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <N extends InnerNode> Object visitNamedListNode(String key, NamedListNode<N> node) {
+        List<Object> list = new ArrayList<>(node.size());
+
+        deque.push(list);
+
+        for (String subkey : node.namedListKeys()) {
+            node.get(subkey).accept(subkey, this);
+
+            ((Map<String, Object>)list.get(list.size() - 1)).put(node.syntheticKeyName(), subkey);
+        }
+
+        deque.pop();
+
+        addToParent(key, list);
+
+        return list;
+    }
+
+    /**
+     * Adds a sub-element to the parent object if it exists.
+     *
+     * @param key Key for the passed element
+     * @param val Value to add to the parent
+     */
+    private void addToParent(String key, Object val) {
+        Object parent = deque.peek();
+
+        if (parent instanceof Map)
+            ((Map<String, Object>)parent).put(key, val);
+        else if (parent instanceof List)
+            ((Collection<Object>)parent).add(val);
+    }
+
+    /**
+     * Converts array into a list of objects. Boxes array elements if they are primitive values.
+     *
+     * @param val Array of primitives or array of {@link String}s
+     * @return List of objects corresponding to the passed array.
+     */
+    private List<?> toListOfObjects(Serializable val) {
+        Stream<?> stream = IntStream.range(0, Array.getLength(val)).mapToObj(i -> Array.get(val, i));
+
+        if (val.getClass().getComponentType() == char.class)
+            stream = stream.map(Object::toString);
+
+        return stream.collect(Collectors.toList());
+    }
+}
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconConverter.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconConverter.java
new file mode 100644
index 0000000..5ce3bd2
--- /dev/null
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconConverter.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration.hocon;
+
+import java.util.List;
+import com.typesafe.config.ConfigObject;
+import com.typesafe.config.ConfigValue;
+import com.typesafe.config.impl.ConfigImpl;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
+import org.jetbrains.annotations.NotNull;
+
+public class HoconConverter {
+    /**
+     * Converts configuration subtree to a HOCON {@link ConfigValue} instance.
+     *
+     * @param registry Configuration registry instance.
+     * @param path Path to the configuration subtree. Can be empty, can't be {@code null}.
+     * @return {@link ConfigValue} instance that represents configuration subtree.
+     * @throws IllegalArgumentException If {@code path} is not found in current configuration.
+     */
+    public static ConfigValue represent(
+        ConfigurationRegistry registry,
+        @NotNull List<String> path
+    ) throws IllegalArgumentException {
+        Object res = registry.represent(path, new HoconConfigurationVisitor());
+
+        return ConfigImpl.fromAnyRef(res, null);
+    }
+
+    /**
+     * @param hoconCfg HOCON that has to be converted to the configuration source.
+     * @return HOCON-based configuration source.
+     */
+    public static ConfigurationSource hoconSource(ConfigObject hoconCfg) {
+        return new HoconObjectConfigurationSource(null, List.of(), hoconCfg);
+    }
+}
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconListConfigurationSource.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconListConfigurationSource.java
new file mode 100644
index 0000000..0deb215
--- /dev/null
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconListConfigurationSource.java
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration.hocon;
+
+import java.lang.reflect.Array;
+import java.util.Iterator;
+import java.util.List;
+import com.typesafe.config.ConfigList;
+import com.typesafe.config.ConfigObject;
+import com.typesafe.config.ConfigValue;
+import com.typesafe.config.ConfigValueType;
+import org.apache.ignite.internal.configuration.TypeUtils;
+import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
+import org.apache.ignite.internal.configuration.tree.ConstructableTreeNode;
+import org.apache.ignite.internal.configuration.tree.NamedListNode;
+
+import static java.lang.String.format;
+import static org.apache.ignite.internal.configuration.hocon.HoconPrimitiveConfigurationSource.formatArrayPath;
+import static org.apache.ignite.internal.configuration.hocon.HoconPrimitiveConfigurationSource.unwrapPrimitive;
+import static org.apache.ignite.internal.configuration.hocon.HoconPrimitiveConfigurationSource.wrongTypeException;
+import static org.apache.ignite.internal.configuration.util.ConfigurationUtil.appendKey;
+import static org.apache.ignite.internal.configuration.util.ConfigurationUtil.join;
+
+/**
+ * {@link ConfigurationSource} created from a HOCON list.
+ */
+class HoconListConfigurationSource implements ConfigurationSource {
+    /**
+     * Current path inside the top-level HOCON object.
+     */
+    private final List<String> path;
+
+    /**
+     * HOCON list that this source has been created from.
+     */
+    private final ConfigList hoconCfgList;
+
+    /**
+     * Creates a {@link ConfigurationSource} from the given HOCON list.
+     *
+     * @param path Current path inside the top-level HOCON object. Can be empty if the given {@code hoconCfgList}
+     *             is the top-level object.
+     * @param hoconCfgList HOCON list.
+     */
+    HoconListConfigurationSource(List<String> path, ConfigList hoconCfgList) {
+        this.path = path;
+        this.hoconCfgList = hoconCfgList;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T unwrap(Class<T> clazz) {
+        if (!clazz.isArray())
+            throw wrongTypeException(clazz, path, -1);
+
+        int size = hoconCfgList.size();
+
+        Class<?> componentType = clazz.getComponentType();
+        Class<?> boxedComponentType = box(componentType);
+
+        Object resArray = Array.newInstance(componentType, size);
+
+        int idx = 0;
+        for (Iterator<ConfigValue> iterator = hoconCfgList.iterator(); iterator.hasNext(); idx++) {
+            ConfigValue hoconCfgListElement = iterator.next();
+
+            switch (hoconCfgListElement.valueType()) {
+                case OBJECT:
+                case LIST:
+                    throw wrongTypeException(boxedComponentType, path, idx);
+
+                default:
+                    Array.set(resArray, idx, unwrapPrimitive(hoconCfgListElement, boxedComponentType, path, idx));
+            }
+        }
+
+        return (T)resArray;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void descend(ConstructableTreeNode node) {
+        if (!(node instanceof NamedListNode)) {
+            throw new IllegalArgumentException(
+                format("'%s' configuration is expected to be a composite configuration node, not a list", join(path))
+            );
+        }
+
+        String syntheticKeyName = ((NamedListNode<?>)node).syntheticKeyName();
+
+        int idx = 0;
+        for (Iterator<ConfigValue> iterator = hoconCfgList.iterator(); iterator.hasNext(); idx++) {
+            ConfigValue next = iterator.next();
+
+            if (next.valueType() != ConfigValueType.OBJECT) {
+                throw new IllegalArgumentException(
+                    format(
+                        "'%s' is expected to be a composite configuration node, not a single value",
+                        formatArrayPath(path, idx)
+                    )
+                );
+            }
+
+            ConfigObject hoconCfg = (ConfigObject)next;
+
+            ConfigValue keyValue = hoconCfg.get(syntheticKeyName);
+
+            if (keyValue == null || keyValue.valueType() != ConfigValueType.STRING) {
+                throw new IllegalArgumentException(
+                    format(
+                        "'%s' configuration value is mandatory and must be a String",
+                        formatArrayPath(path, idx) + "." + syntheticKeyName
+                    )
+                );
+            }
+
+            String key = (String)keyValue.unwrapped();
+
+            List<String> path = appendKey(this.path, syntheticKeyName);
+
+            node.construct(key, new HoconObjectConfigurationSource(syntheticKeyName, path, hoconCfg));
+        }
+    }
+
+    /**
+     * Non-null wrapper over {@link TypeUtils#boxed}.
+     *
+     * @param clazz Class, either primitive or not.
+     * @return Boxed version of passed class.
+     */
+    public static Class<?> box(Class<?> clazz) {
+        Class<?> boxed = TypeUtils.boxed(clazz);
+
+        return boxed == null ? clazz : boxed;
+    }
+}
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconObjectConfigurationSource.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconObjectConfigurationSource.java
new file mode 100644
index 0000000..ce6f14c
--- /dev/null
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconObjectConfigurationSource.java
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration.hocon;
+
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import com.typesafe.config.ConfigList;
+import com.typesafe.config.ConfigObject;
+import com.typesafe.config.ConfigValue;
+import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
+import org.apache.ignite.internal.configuration.tree.ConstructableTreeNode;
+import org.jetbrains.annotations.Nullable;
+
+import static java.lang.String.format;
+import static org.apache.ignite.internal.configuration.hocon.HoconPrimitiveConfigurationSource.wrongTypeException;
+import static org.apache.ignite.internal.configuration.util.ConfigurationUtil.appendKey;
+import static org.apache.ignite.internal.configuration.util.ConfigurationUtil.join;
+
+/**
+ * {@link ConfigurationSource} created from a HOCON object.
+ */
+class HoconObjectConfigurationSource implements ConfigurationSource {
+    /**
+     * Key that needs to be ignored by the source. Can be {@code null}.
+     */
+    private final String ignoredKey;
+
+    /**
+     * Current path inside the top-level HOCON object.
+     */
+    private final List<String> path;
+
+    /**
+     * HOCON object that this source has been created from.
+     */
+    private final ConfigObject hoconCfgObject;
+
+    /**
+     * Creates a {@link ConfigurationSource} from the given HOCON object.
+     *
+     * @param ignoredKey Key that needs to be ignored by the source. Can be {@code null}.
+     * @param path Current path inside the top-level HOCON object. Can be empty if the given {@code hoconCfgObject}
+     *             is the top-level object.
+     * @param hoconCfgObject HOCON object.
+     */
+    HoconObjectConfigurationSource(@Nullable String ignoredKey, List<String> path, ConfigObject hoconCfgObject) {
+        this.ignoredKey = ignoredKey;
+        this.path = path;
+        this.hoconCfgObject = hoconCfgObject;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T unwrap(Class<T> clazz) {
+        throw wrongTypeException(clazz, path, -1);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void descend(ConstructableTreeNode node) {
+        for (Map.Entry<String, ConfigValue> entry : hoconCfgObject.entrySet()) {
+            String key = entry.getKey();
+
+            if (key.equals(ignoredKey))
+                continue;
+
+            ConfigValue hoconCfgValue = entry.getValue();
+
+            try {
+                switch (hoconCfgValue.valueType()) {
+                    case NULL:
+                        node.construct(key, null);
+
+                        break;
+
+                    case OBJECT: {
+                        List<String> path = appendKey(this.path, key);
+
+                        node.construct(key, new HoconObjectConfigurationSource(null, path, (ConfigObject)hoconCfgValue));
+
+                        break;
+                    }
+
+                    case LIST: {
+                        List<String> path = appendKey(this.path, key);
+
+                        node.construct(key, new HoconListConfigurationSource(path, (ConfigList)hoconCfgValue));
+
+                        break;
+                    }
+
+                    default: {
+                        List<String> path = appendKey(this.path, key);
+
+                        node.construct(key, new HoconPrimitiveConfigurationSource(path, hoconCfgValue));
+                    }
+                }
+            }
+            catch (NoSuchElementException e) {
+                if (path.isEmpty()) {
+                    throw new IllegalArgumentException(
+                        format("'%s' configuration root doesn't exist", key), e
+                    );
+                }
+                else {
+                    throw new IllegalArgumentException(
+                        format("'%s' configuration doesn't have the '%s' sub-configuration", join(path), key), e
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconPrimitiveConfigurationSource.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconPrimitiveConfigurationSource.java
new file mode 100644
index 0000000..6362861
--- /dev/null
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/hocon/HoconPrimitiveConfigurationSource.java
@@ -0,0 +1,199 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration.hocon;
+
+import java.util.List;
+import com.typesafe.config.ConfigValue;
+import org.apache.ignite.internal.configuration.TypeUtils;
+import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
+import org.apache.ignite.internal.configuration.tree.ConstructableTreeNode;
+
+import static com.typesafe.config.ConfigValueType.BOOLEAN;
+import static com.typesafe.config.ConfigValueType.NUMBER;
+import static com.typesafe.config.ConfigValueType.STRING;
+import static java.lang.String.format;
+import static org.apache.ignite.internal.configuration.util.ConfigurationUtil.join;
+
+/**
+ * {@link ConfigurationSource} created from a HOCON element representing a primitive type.
+ */
+class HoconPrimitiveConfigurationSource implements ConfigurationSource {
+    /**
+     * Current path inside the top-level HOCON object.
+     */
+    private final List<String> path;
+
+    /**
+     * HOCON object that this source has been created from.
+     */
+    private final ConfigValue hoconCfgValue;
+
+    /**
+     * Creates a {@link ConfigurationSource} from the given HOCON object representing a primitive type.
+     *
+     * @param path current path inside the top-level HOCON object. Can be empty if the given {@code hoconCfgValue}
+     *             is the top-level object
+     * @param hoconCfgValue HOCON object
+     */
+    HoconPrimitiveConfigurationSource(List<String> path, ConfigValue hoconCfgValue) {
+        assert !path.isEmpty();
+
+        this.path = path;
+        this.hoconCfgValue = hoconCfgValue;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T unwrap(Class<T> clazz) {
+        if (clazz.isArray())
+            throw wrongTypeException(clazz, path, -1);
+
+        return unwrapPrimitive(hoconCfgValue, clazz, path, -1);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void descend(ConstructableTreeNode node) {
+        throw new IllegalArgumentException(
+            format("'%s' is expected to be a composite configuration node, not a single value", join(path))
+        );
+    }
+
+    /**
+     * Returns exception with the message that a value is expected to be of a specific type.
+     *
+     * @param clazz Expected type of the value.
+     * @param path Path to the value.
+     * @param idx Index in the array if the value is an array element. {@code -1} if it's not.
+     * @return New {@link IllegalArgumentException} instance.
+     */
+    public static IllegalArgumentException wrongTypeException(Class<?> clazz, List<String> path, int idx) {
+        return new IllegalArgumentException(format(
+            "'%s' is expected as a type for the '%s' configuration value",
+            unbox(clazz).getSimpleName(), formatArrayPath(path, idx)
+        ));
+    }
+
+    /**
+     * Non-null wrapper over {@link TypeUtils#unboxed}.
+     *
+     * @param clazz Class for non-primitive objects.
+     * @return Unboxed class fox boxed classes, same object otherwise.
+     */
+    private static Class<?> unbox(Class<?> clazz) {
+        assert !clazz.isPrimitive();
+
+        Class<?> unboxed = TypeUtils.unboxed(clazz);
+
+        return unboxed == null ? clazz : unboxed;
+    }
+
+    /**
+     * Extracts the value from the given {@link ConfigValue} based on the expected type.
+     *
+     * @param hoconCfgValue Configuration value to unwrap.
+     * @param clazz Class that signifies resulting type of the value. Boxed primitive or String.
+     * @param path Path to the value, used for error messages.
+     * @param idx Index in the array if the value is an array element. {@code -1} if it's not.
+     * @param <T> Type of the resulting unwrapped object.
+     * @return Unwrapped object.
+     * @throws IllegalArgumentException In case of type mismatch or numeric overflow.
+     */
+    public static <T> T unwrapPrimitive(ConfigValue hoconCfgValue, Class<T> clazz, List<String> path, int idx) {
+        assert !clazz.isArray();
+        assert !clazz.isPrimitive();
+
+        if (clazz == String.class) {
+            if (hoconCfgValue.valueType() != STRING)
+                throw wrongTypeException(clazz, path, idx);
+
+            return clazz.cast(hoconCfgValue.unwrapped());
+        }
+        else if (clazz == Boolean.class) {
+            if (hoconCfgValue.valueType() != BOOLEAN)
+                throw wrongTypeException(clazz, path, idx);
+
+            return clazz.cast(hoconCfgValue.unwrapped());
+        }
+        else if (clazz == Character.class) {
+            if (hoconCfgValue.valueType() != STRING || hoconCfgValue.unwrapped().toString().length() != 1)
+                throw wrongTypeException(clazz, path, idx);
+
+            return clazz.cast(hoconCfgValue.unwrapped().toString().charAt(0));
+        }
+        else if (Number.class.isAssignableFrom(clazz)) {
+            if (hoconCfgValue.valueType() != NUMBER)
+                throw wrongTypeException(clazz, path, idx);
+
+            Number numberValue = (Number)hoconCfgValue.unwrapped();
+
+            if (clazz == Byte.class) {
+                checkBounds(numberValue, Byte.MIN_VALUE, Byte.MAX_VALUE, path, idx);
+
+                return clazz.cast(numberValue.byteValue());
+            }
+            else if (clazz == Short.class) {
+                checkBounds(numberValue, Short.MIN_VALUE, Short.MAX_VALUE, path, idx);
+
+                return clazz.cast(numberValue.shortValue());
+            }
+            else if (clazz == Integer.class) {
+                checkBounds(numberValue, Integer.MIN_VALUE, Integer.MAX_VALUE, path, idx);
+
+                return clazz.cast(numberValue.intValue());
+            }
+            else if (clazz == Long.class)
+                return clazz.cast(numberValue.longValue());
+            else if (clazz == Float.class)
+                return clazz.cast(numberValue.floatValue());
+            else if (clazz == Double.class)
+                return clazz.cast(numberValue.doubleValue());
+        }
+
+        throw new IllegalArgumentException("Unsupported type: " + clazz);
+    }
+
+    /**
+     * Checks that a number fits into the given bounds.
+     *
+     * @param numberValue Number value to validate.
+     * @param lower Lower bound, inclusive.
+     * @param upper Upper bound, inclusive.
+     * @param path Path to the value, used for error messages.
+     * @param idx Index in the array if the value is an array element. {@code -1} if it's not.
+     */
+    private static void checkBounds(Number numberValue, long lower, long upper, List<String> path, int idx) {
+        long longValue = numberValue.longValue();
+
+        if (longValue < lower || longValue > upper) {
+            throw new IllegalArgumentException(format(
+                "Value '%d' of '%s' is out of its declared bounds: [%d : %d]",
+                longValue, formatArrayPath(path, idx), lower, upper
+            ));
+        }
+    }
+
+    /**
+     * Creates a string representation of the current HOCON path inside of an array.
+     *
+     * @param path Path to the value.
+     * @param idx Index in the array if the value is an array element. {@code -1} if it's not.
+     * @return Path in a proper format.
+     */
+    public static String formatArrayPath(List<String> path, int idx) {
+        return join(path) + (idx == -1 ? "" : ("[" + idx + "]"));
+    }
+}
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/NamedListNode.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/NamedListNode.java
index 0cd3874..6a90b15 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/NamedListNode.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/NamedListNode.java
@@ -23,6 +23,7 @@
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import org.apache.ignite.configuration.NamedListChange;
+import org.apache.ignite.configuration.annotation.NamedConfigValue;
 
 /**
  * Configuration node implementation for the collection of named {@link InnerNode}s. Unlike implementations of
@@ -34,6 +35,9 @@
     /** Name of a synthetic configuration property that describes the order of elements in a named list. */
     public static final String ORDER_IDX = "<idx>";
 
+    /** Configuration name for the synthetic key. */
+    private final String syntheticKeyName;
+
     /** Supplier of new node objects when new list element node has to be created. */
     private final Supplier<N> valSupplier;
 
@@ -43,9 +47,12 @@
     /**
      * Default constructor.
      *
+     * @param syntheticKeyName Name of the synthetic configuration value that will represent keys in a specially ordered
+     *      representation syntax.
      * @param valSupplier Closure to instantiate values.
      */
-    public NamedListNode(Supplier<N> valSupplier) {
+    public NamedListNode(String syntheticKeyName, Supplier<N> valSupplier) {
+        this.syntheticKeyName = syntheticKeyName;
         this.valSupplier = valSupplier;
         map = new OrderedMap<>();
     }
@@ -56,6 +63,7 @@
      * @param node Other node.
      */
     private NamedListNode(NamedListNode<N> node) {
+        syntheticKeyName = node.syntheticKeyName;
         valSupplier = node.valSupplier;
         map = new OrderedMap<>(node.map);
     }
@@ -76,6 +84,11 @@
     }
 
     /** {@inheritDoc} */
+    @Override public N get(int index) throws IndexOutOfBoundsException {
+        return map.get(index);
+    }
+
+    /** {@inheritDoc} */
     @Override public int size() {
         return map.size();
     }
@@ -180,6 +193,15 @@
     }
 
     /**
+     * @return Configuration name for the synthetic key.
+     *
+     * @see NamedConfigValue#syntheticKeyName()
+     */
+    public String syntheticKeyName() {
+        return syntheticKeyName;
+    }
+
+    /**
      * Deletes named list element.
      *
      * @param key Element's key.
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/OrderedMap.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/OrderedMap.java
index d67d3f3..024963a 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/OrderedMap.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/OrderedMap.java
@@ -72,6 +72,17 @@
     }
 
     /**
+     * Returns value located at the specified index.
+     *
+     * @param index Value index.
+     * @return Requested value.
+     * @throws IndexOutOfBoundsException If index is out of bounds.
+     */
+    public V get(int index) {
+        return map.get(orderedKeys.get(index));
+    }
+
+    /**
      * Same as {@link Map#remove(Object)}.
      *
      * @param key Key to remove.
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/OrderedMapTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/OrderedMapTest.java
index 580d181..8863d89 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/OrderedMapTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/OrderedMapTest.java
@@ -23,6 +23,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 /** Test with basic {@link OrderedMap} invariants. */
 public class OrderedMapTest {
@@ -38,10 +39,13 @@
 
         assertEquals(1, map.size());
         assertEquals("value", map.get("key"));
+        assertEquals("value", map.get(0));
 
         map.remove("key");
 
         assertNull(map.get("key1"));
+
+        assertThrows(IndexOutOfBoundsException.class, () -> map.get(0));
     }
 
     /** Tests that {@link OrderedMap#put(String, Object)} preserves order. */