diff --git a/config/config-mp/pom.xml b/config/config-mp/pom.xml
index add2ae247ae..21242141df5 100644
--- a/config/config-mp/pom.xml
+++ b/config/config-mp/pom.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-  ~ Copyright (c) 2020 Oracle and/or its affiliates.
+  ~ Copyright (c) 2020, 2021 Oracle and/or its affiliates.
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
@@ -50,6 +50,10 @@
             <groupId>org.eclipse.microprofile.config</groupId>
             <artifactId>microprofile-config-api</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.config</groupId>
+            <artifactId>helidon-config-yaml</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
diff --git a/config/config-mp/src/main/java/io/helidon/config/mp/MpConfigBuilder.java b/config/config-mp/src/main/java/io/helidon/config/mp/MpConfigBuilder.java
index 9ddf8e6922c..4e18cb6258d 100644
--- a/config/config-mp/src/main/java/io/helidon/config/mp/MpConfigBuilder.java
+++ b/config/config-mp/src/main/java/io/helidon/config/mp/MpConfigBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2021 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,6 +24,7 @@
 import java.net.URI;
 import java.net.URL;
 import java.nio.charset.Charset;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.time.Duration;
@@ -50,12 +51,16 @@
 import java.util.SimpleTimeZone;
 import java.util.TimeZone;
 import java.util.UUID;
+import java.util.function.Function;
 import java.util.regex.Pattern;
 
 import io.helidon.common.serviceloader.HelidonServiceLoader;
 import io.helidon.common.serviceloader.Priorities;
+import io.helidon.config.ConfigException;
 import io.helidon.config.ConfigMappers;
+import io.helidon.config.ConfigValue;
 import io.helidon.config.mp.spi.MpConfigFilter;
+import io.helidon.config.yaml.YamlMpConfigSource;
 
 import org.eclipse.microprofile.config.Config;
 import org.eclipse.microprofile.config.spi.ConfigBuilder;
@@ -63,6 +68,8 @@
 import org.eclipse.microprofile.config.spi.ConfigSourceProvider;
 import org.eclipse.microprofile.config.spi.Converter;
 
+import static io.helidon.config.mp.MpMetaConfig.MetaConfigSource;
+
 /**
  * Configuration builder.
  */
@@ -125,6 +132,141 @@ public ConfigBuilder withConverters(Converter<?>... converters) {
         return this;
     }
 
+    void mpMetaConfig(io.helidon.config.Config meta) {
+        meta.get("add-discovered-sources")
+                .asBoolean()
+                .filter(it -> it)
+                .ifPresent(it -> addDiscoveredSources());
+
+        meta.get("add-discovered-converters")
+                .asBoolean()
+                .filter(it -> it)
+                .ifPresent(it -> addDiscoveredConverters());
+
+        meta.get("add-default-sources")
+                .asBoolean()
+                .filter(it -> it)
+                .ifPresent(it -> addDefaultSources());
+
+        meta.get("sources")
+                .asNodeList()
+                .ifPresent(this::processMetaSources);
+    }
+
+    private void processMetaSources(List<io.helidon.config.Config> configs) {
+        for (io.helidon.config.Config config : configs) {
+            String type = config.get("type").asString()
+                    .orElseThrow(() -> new ConfigException("Meta configuration sources must have a \"type\" property defined"));
+            // in MP, we have a hardcoded list of supported configuration source types
+            List<ConfigSource> delegates;
+            switch (type) {
+            case "system-properties":
+                delegates = List.of(MpConfigSources.systemProperties());
+                break;
+            case "environment-variables":
+                delegates = List.of(MpConfigSources.environmentVariables());
+                break;
+            case "properties":
+                delegates = propertiesSource(config);
+                break;
+            case "yaml":
+                delegates = yamlSource(config);
+                break;
+            default:
+                throw new ConfigException("Meta configuration source type \"" + type + "\" is not supported. Use on of: "
+                                                  + "system-properties, environment-variables, properties, yaml");
+            }
+            boolean shouldCount = delegates.size() > 1;
+            int counter = 0;
+
+            for (ConfigSource delegate : delegates) {
+                MetaConfigSource.Builder builder = MetaConfigSource.builder()
+                        .delegate(delegate);
+
+                config.get("ordinal").asInt().ifPresent(builder::ordinal);
+                ConfigValue<String> name = config.get("name").asString();
+                if (shouldCount) {
+                    if (name.isPresent()) {
+                        // multiple instances - count them
+                        builder.name(name.get() + "_" + counter++);
+                    }
+                } else {
+                    name.ifPresent(builder::name);
+                }
+
+                withSources(builder.build());
+            }
+        }
+    }
+
+    private List<ConfigSource> propertiesSource(io.helidon.config.Config config) {
+        return sourceFromMeta(config,
+                              MpConfigSources::create,
+                              MpConfigSources::classPath,
+                              MpConfigSources::create);
+    }
+
+    private List<ConfigSource> yamlSource(io.helidon.config.Config config) {
+        return sourceFromMeta(config,
+                              YamlMpConfigSource::create,
+                              YamlMpConfigSource::classPath,
+                              YamlMpConfigSource::create);
+    }
+
+    private List<ConfigSource> sourceFromMeta(io.helidon.config.Config config,
+                                              Function<Path, ConfigSource> fromPath,
+                                              Function<String, List<ConfigSource>> fromClasspath,
+                                              Function<URL, ConfigSource> fromUrl) {
+
+        boolean optional = config.get("optional").asBoolean().orElse(false);
+
+        String location;
+        Exception cause = null;
+
+        ConfigValue<Path> pathConfig = config.get("path").as(Path.class);
+        if (pathConfig.isPresent()) {
+            Path path = pathConfig.get();
+            if (Files.exists(path) && Files.isRegularFile(path)) {
+                return List.of(fromPath.apply(path));
+            }
+            location = "path " + path.toAbsolutePath();
+        } else {
+            ConfigValue<String> classpathConfig = config.get("classpath").as(String.class);
+            if (classpathConfig.isPresent()) {
+                String classpath = classpathConfig.get();
+                List<ConfigSource> sources = fromClasspath.apply(classpath);
+                if (!sources.isEmpty()) {
+                    return sources;
+                }
+                location = "classpath " + classpath;
+            } else {
+                ConfigValue<URL> urlConfig = config.get("url").as(URL.class);
+                if (urlConfig.isPresent()) {
+                    URL url = urlConfig.get();
+                    try {
+                        return List.of(fromUrl.apply(url));
+                    } catch (ConfigException e) {
+                        location = "url " + url;
+                        cause = e;
+                    }
+                } else {
+                    throw new ConfigException("MP meta configuration does not contain config source location. Node: " + config
+                            .key());
+                }
+            }
+        }
+
+        if (optional) {
+            return List.of();
+        }
+        String message = "Meta configuration could not find non-optional config source on " + location;
+        if (cause == null) {
+            throw new ConfigException(message);
+        } else {
+            throw new ConfigException(message, cause);
+        }
+    }
+
     @Override
     public Config build() {
         if (useDefaultSources) {
diff --git a/config/config-mp/src/main/java/io/helidon/config/mp/MpConfigProviderResolver.java b/config/config-mp/src/main/java/io/helidon/config/mp/MpConfigProviderResolver.java
index 8e69bb58e59..ef485b95bbc 100644
--- a/config/config-mp/src/main/java/io/helidon/config/mp/MpConfigProviderResolver.java
+++ b/config/config-mp/src/main/java/io/helidon/config/mp/MpConfigProviderResolver.java
@@ -28,6 +28,7 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.logging.Logger;
 import java.util.stream.Stream;
 
 import io.helidon.common.GenericType;
@@ -44,6 +45,7 @@
  * This class is an implementation of a java service obtained through ServiceLoader.
  */
 public class MpConfigProviderResolver extends ConfigProviderResolver {
+    private static final Logger LOGGER = Logger.getLogger(MpConfigProviderResolver.class.getName());
     private static final Map<ClassLoader, ConfigDelegate> CONFIGS = new IdentityHashMap<>();
     private static final ReadWriteLock RW_LOCK = new ReentrantReadWriteLock();
     // specific for native image - we want to replace config provided during build with runtime configuration
@@ -83,20 +85,31 @@ public Config getConfig(ClassLoader classLoader) {
 
     private Config buildConfig(ClassLoader loader) {
         MpConfigBuilder builder = getBuilder();
+        builder.forClassLoader(loader);
 
-        Optional<io.helidon.config.Config> meta = MetaConfig.metaConfig();
+        // MP Meta Configuration
+        Optional<io.helidon.config.Config> meta = MpMetaConfig.metaConfig();
 
-        meta.ifPresent(builder::metaConfig);
+        if (meta.isEmpty()){
+            meta = MetaConfig.metaConfig();
 
-        builder.forClassLoader(loader);
+            if (meta.isPresent()) {
+                builder.metaConfig(meta.get());
+                LOGGER.warning("You are using Helidon SE meta configuration in a Helidon MP application. Some features "
+                                       + "work differently, such as environment variable resolving, and mutability");
+            }
+        } else {
+            builder.mpMetaConfig(meta.get());
+        }
 
         if (meta.isEmpty()) {
+            // no meta configuration, use defaults
             builder.addDefaultSources();
+            builder.addDiscoveredSources();
+            builder.addDiscoveredConverters();
         }
 
-        return builder.addDiscoveredSources()
-                .addDiscoveredConverters()
-                .build();
+        return builder.build();
     }
 
     @Override
diff --git a/config/config-mp/src/main/java/io/helidon/config/mp/MpMetaConfig.java b/config/config-mp/src/main/java/io/helidon/config/mp/MpMetaConfig.java
new file mode 100644
index 00000000000..628a63138df
--- /dev/null
+++ b/config/config-mp/src/main/java/io/helidon/config/mp/MpMetaConfig.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates.
+ *
+ * Licensed 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 io.helidon.config.mp;
+
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.logging.Logger;
+
+import io.helidon.config.Config;
+import io.helidon.config.ConfigSources;
+import io.helidon.config.spi.ConfigSource;
+
+final class MpMetaConfig {
+    private static final String META_CONFIG_ENV_VAR = "HELIDON_MP_META_CONFIG";
+    static final String META_CONFIG_SYSTEM_PROPERTY = "io.helidon.config.mp.meta-config";
+
+    private static final Logger LOGGER = Logger.getLogger(MpMetaConfig.class.getName());
+
+    private MpMetaConfig() {
+    }
+
+    static Optional<Config> metaConfig() {
+        return findMetaConfig()
+                .map(it -> Config.builder()
+                        .disableValueResolving()
+                        .disableKeyResolving()
+                        .disableFilterServices()
+                        .disableEnvironmentVariablesSource()
+                        .disableSystemPropertiesSource()
+                        .disableMapperServices()
+                        .addSource(it)
+                        .build());
+    }
+
+    private static Optional<ConfigSource> findMetaConfig() {
+        String fileName = System.getenv(META_CONFIG_ENV_VAR);
+        if (fileName == null) {
+            fileName = System.getProperty(META_CONFIG_SYSTEM_PROPERTY);
+        }
+        Optional<ConfigSource> found;
+        if (fileName == null) {
+            found = Optional.empty();
+        } else {
+            found = findMetaConfig(fileName);
+        }
+
+        return found.or(() -> findMetaConfig("mp-meta-config.yaml"))
+                .or(() -> findMetaConfig("mp-meta-config.properties"));
+    }
+
+    private static Optional<ConfigSource> findMetaConfig(String fileName) {
+        // file system, then classpath
+        return findFile(fileName)
+                .or(() -> findClasspath(MpMetaConfig.class.getClassLoader(), fileName));
+    }
+
+    private static Optional<ConfigSource> findFile(String name) {
+        Path path = Paths.get(name);
+        if (Files.exists(path) && Files.isReadable(path) && !Files.isDirectory(path)) {
+            LOGGER.info("Found MP meta configuration file: " + path.toAbsolutePath());
+            return Optional.of(ConfigSources.file(path).build());
+        }
+        return Optional.empty();
+    }
+
+    private static Optional<ConfigSource> findClasspath(ClassLoader cl, String name) {
+        // so it is a classpath resource?
+        URL resource = cl.getResource(name);
+        if (null != resource) {
+            LOGGER.fine(() -> "Found MP meta configuration resource: " + resource.getPath());
+            return Optional.of(ConfigSources.classpath(name).build());
+        }
+        return Optional.empty();
+    }
+
+    static class MetaConfigSource implements org.eclipse.microprofile.config.spi.ConfigSource {
+        private final org.eclipse.microprofile.config.spi.ConfigSource delegate;
+        private final int ordinal;
+        private final String name;
+
+        MetaConfigSource(Builder builder) {
+            this.delegate = builder.delegate;
+            this.ordinal = builder.ordinal;
+            this.name = builder.sourceName;
+        }
+
+        static Builder builder() {
+            return new Builder();
+        }
+
+        @Override
+        public Map<String, String> getProperties() {
+            return delegate.getProperties();
+        }
+
+        @Override
+        public String getValue(String propertyName) {
+            return delegate.getValue(propertyName);
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        @Override
+        public Set<String> getPropertyNames() {
+            return delegate.getPropertyNames();
+        }
+
+        @Override
+        public int getOrdinal() {
+            return ordinal;
+        }
+
+        @Override
+        public String toString() {
+            return name + "(" + ordinal + ")" + ", wrapping: " + delegate.toString();
+        }
+
+        static class Builder implements io.helidon.common.Builder<MetaConfigSource> {
+            private org.eclipse.microprofile.config.spi.ConfigSource delegate;
+            private int ordinal;
+            private boolean ordinalNotSet = true;
+            private String sourceName;
+            private boolean nameNotSet = true;
+
+            private Builder() {
+            }
+
+            @Override
+            public MetaConfigSource build() {
+                return new MetaConfigSource(this);
+            }
+
+            Builder delegate(org.eclipse.microprofile.config.spi.ConfigSource delegate) {
+                this.delegate = delegate;
+                if (this.ordinalNotSet) {
+                    this.ordinal = delegate.getOrdinal();
+                }
+                if (this.nameNotSet) {
+                    this.sourceName = delegate.getName();
+                }
+                return this;
+            }
+
+            Builder ordinal(int ordinal) {
+                this.ordinal = ordinal;
+                this.ordinalNotSet = false;
+                return this;
+            }
+
+            Builder name(String sourceName) {
+                this.sourceName = sourceName;
+                this.nameNotSet = false;
+                return this;
+            }
+        }
+    }
+}
diff --git a/config/config-mp/src/main/java/module-info.java b/config/config-mp/src/main/java/module-info.java
index f0c082201b8..253fa705f91 100644
--- a/config/config-mp/src/main/java/module-info.java
+++ b/config/config-mp/src/main/java/module-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2021 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,7 @@
     requires java.logging;
     requires io.helidon.common;
     requires io.helidon.config;
+    requires io.helidon.config.yaml;
     requires transitive microprofile.config.api;
     requires java.annotation;
     requires io.helidon.common.serviceloader;
diff --git a/config/config-mp/src/test/java/io/helidon/config/mp/MpMetaConfigTest.java b/config/config-mp/src/test/java/io/helidon/config/mp/MpMetaConfigTest.java
new file mode 100644
index 00000000000..3903c3e39df
--- /dev/null
+++ b/config/config-mp/src/test/java/io/helidon/config/mp/MpMetaConfigTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates.
+ *
+ * Licensed 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 io.helidon.config.mp;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.eclipse.microprofile.config.Config;
+import org.eclipse.microprofile.config.ConfigProvider;
+import org.eclipse.microprofile.config.spi.ConfigProviderResolver;
+import org.eclipse.microprofile.config.spi.ConfigSource;
+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 static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.iterableWithSize;
+
+class MpMetaConfigTest {
+    private static ConfigProviderResolver configResolver;
+    private Config config;
+
+    @BeforeAll
+    static void getProviderResolver() {
+        configResolver = ConfigProviderResolver.instance();
+    }
+    @AfterAll
+    static void resetSystemProperties() {
+        System.clearProperty(MpMetaConfig.META_CONFIG_SYSTEM_PROPERTY);
+    }
+
+    @BeforeEach
+    void resetConfig() {
+        if (config == null) {
+            // first run - need to remove existing props
+            System.clearProperty(MpMetaConfig.META_CONFIG_SYSTEM_PROPERTY);
+            configResolver.releaseConfig(ConfigProvider.getConfig());
+        } else {
+            configResolver.releaseConfig(config);
+            config = null;
+        }
+    }
+
+    @Test
+    void testMetaYaml() {
+        System.setProperty(MpMetaConfig.META_CONFIG_SYSTEM_PROPERTY, "custom-mp-meta-config.yaml");
+        config = ConfigProvider.getConfig();
+
+        // validate the config sources
+        Iterable<ConfigSource> configSources = config.getConfigSources();
+        List<String> sourceNames = new LinkedList<>();
+        configSources.forEach(it -> sourceNames.add(it.getName()));
+
+        assertThat(sourceNames, iterableWithSize(2));
+        assertThat(sourceNames.get(0), is("CLASSPATH"));
+        assertThat(config.getValue("value", String.class), is("classpath"));
+    }
+
+    @Test
+    void testMetaProperties() {
+        System.setProperty(MpMetaConfig.META_CONFIG_SYSTEM_PROPERTY, "custom-mp-meta-config.properties");
+        config = ConfigProvider.getConfig();
+        assertThat(config.getValue("value", String.class), is("path"));
+    }
+
+    @Test
+    void testMetaDefault() {
+        config = ConfigProvider.getConfig();
+        assertThat(config.getValue("value", String.class), is("default"));
+    }
+}
diff --git a/config/config-mp/src/test/resources/META-INF/microprofile-config.properties b/config/config-mp/src/test/resources/META-INF/microprofile-config.properties
index 45ff59e5d8a..b1dce83318e 100644
--- a/config/config-mp/src/test/resources/META-INF/microprofile-config.properties
+++ b/config/config-mp/src/test/resources/META-INF/microprofile-config.properties
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2020 Oracle and/or its affiliates.
+# Copyright (c) 2020, 2021 Oracle and/or its affiliates.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,6 +14,8 @@
 # limitations under the License.
 #
 
+value=default
+
 value1=value
 
 referencing1-1=${value1}
diff --git a/config/config-mp/src/test/resources/custom-mp-meta-config.properties b/config/config-mp/src/test/resources/custom-mp-meta-config.properties
new file mode 100644
index 00000000000..31ea10d0442
--- /dev/null
+++ b/config/config-mp/src/test/resources/custom-mp-meta-config.properties
@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2021 Oracle and/or its affiliates.
+#
+# Licensed 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.
+#
+
+add-discovered-sources=false
+add-discovered-converters=false
+
+sources.0.type=properties
+sources.0.classpath=meta-config/classpath.properties
+sources.1.type=properties
+sources.1.path=src/test/resources/meta-config/path.properties
diff --git a/config/config-mp/src/test/resources/custom-mp-meta-config.yaml b/config/config-mp/src/test/resources/custom-mp-meta-config.yaml
new file mode 100644
index 00000000000..745e2d161c4
--- /dev/null
+++ b/config/config-mp/src/test/resources/custom-mp-meta-config.yaml
@@ -0,0 +1,35 @@
+#
+# Copyright (c) 2021 Oracle and/or its affiliates.
+#
+# Licensed 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.
+#
+
+add-discovered-sources: false
+add-discovered-converters: false
+#future compatibility
+#config-profile: "dev"
+
+sources:
+  - type: "properties"
+    path: "src/test/resources/meta-config/path.properties"
+    ordinal: 50
+  - type: "yaml"
+    classpath: "custom-application.yaml"
+    optional: true
+  - type: "properties"
+    classpath: "meta-config/classpath.properties"
+    name: "CLASSPATH"
+    # not sure how to test URL based unless we start a server
+#  - type: "yaml"
+#    url: "helidon-test:meta-config/url.yaml"
+#    name: "URL"
\ No newline at end of file
diff --git a/config/config-mp/src/test/resources/meta-config/classpath.properties b/config/config-mp/src/test/resources/meta-config/classpath.properties
new file mode 100644
index 00000000000..a425c2dbb47
--- /dev/null
+++ b/config/config-mp/src/test/resources/meta-config/classpath.properties
@@ -0,0 +1,18 @@
+#
+# Copyright (c) 2021 Oracle and/or its affiliates.
+#
+# Licensed 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.
+#
+
+value=classpath
+config_ordinal=125
diff --git a/config/config-mp/src/test/resources/meta-config/path.properties b/config/config-mp/src/test/resources/meta-config/path.properties
new file mode 100644
index 00000000000..f4c80c993de
--- /dev/null
+++ b/config/config-mp/src/test/resources/meta-config/path.properties
@@ -0,0 +1,18 @@
+#
+# Copyright (c) 2021 Oracle and/or its affiliates.
+#
+# Licensed 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.
+#
+
+value=path
+config_ordinal=150
diff --git a/config/config-mp/src/test/resources/meta-config/url.yaml b/config/config-mp/src/test/resources/meta-config/url.yaml
new file mode 100644
index 00000000000..a4856ccfc9a
--- /dev/null
+++ b/config/config-mp/src/test/resources/meta-config/url.yaml
@@ -0,0 +1,18 @@
+#
+# Copyright (c) 2021 Oracle and/or its affiliates.
+#
+# Licensed 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.
+#
+
+value: "url"
+config_ordinal: 175
\ No newline at end of file
diff --git a/config/config-mp/src/test/resources/mp-meta-config.properties b/config/config-mp/src/test/resources/mp-meta-config.properties
new file mode 100644
index 00000000000..96ff1385972
--- /dev/null
+++ b/config/config-mp/src/test/resources/mp-meta-config.properties
@@ -0,0 +1,20 @@
+#
+# Copyright (c) 2021 Oracle and/or its affiliates.
+#
+# Licensed 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.
+#
+
+# as if default
+add-discovered-sources=true
+add-discovered-converters=true
+add-default-sources=true
diff --git a/config/yaml/src/main/java/io/helidon/config/yaml/YamlMpConfigSource.java b/config/yaml/src/main/java/io/helidon/config/yaml/YamlMpConfigSource.java
index 7e361db21d0..9abf62be064 100644
--- a/config/yaml/src/main/java/io/helidon/config/yaml/YamlMpConfigSource.java
+++ b/config/yaml/src/main/java/io/helidon/config/yaml/YamlMpConfigSource.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2021 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@
 
 package io.helidon.config.yaml;
 
+import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.net.MalformedURLException;
@@ -24,6 +25,7 @@
 import java.nio.file.Path;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
@@ -123,6 +125,25 @@ public static ConfigSource create(String name, Reader content) {
 
     }
 
+    /**
+     * Create from YAML file(s) on classpath.
+     *
+     * @param resource resource name to locate on classpath (looks for all instances)
+     * @return list of config sources discovered (may be zero length)
+     */
+    public static List<ConfigSource> classPath(String resource) {
+        List<ConfigSource> sources = new LinkedList<>();
+        try {
+            Thread.currentThread().getContextClassLoader().getResources(resource)
+                    .asIterator()
+                    .forEachRemaining(it -> sources.add(create(it)));
+        } catch (IOException e) {
+            throw new IllegalStateException("Failed to read YAML \"" + resource + "\" from classpath", e);
+        }
+
+        return sources;
+    }
+
     @Override
     public Map<String, String> getProperties() {
         return Collections.unmodifiableMap(properties);
diff --git a/docs/mp/config/01_introduction.adoc b/docs/mp/config/01_introduction.adoc
index 4ae37467059..5cd1b22171e 100644
--- a/docs/mp/config/01_introduction.adoc
+++ b/docs/mp/config/01_introduction.adoc
@@ -1,7 +1,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-    Copyright (c) 2020 Oracle and/or its affiliates.
+    Copyright (c) 2020, 2021 Oracle and/or its affiliates.
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -115,43 +115,52 @@ client_secret=${CLEAR=known_password}
 ----
 
 * *Meta Configuration* +
-You can configure the Config using Helidon SE Config meta configuration feature.
-When used, the {spec-name} uses a single configuration source - Helidon SE Config configured
-from meta configuration.
+You can configure the Config using Helidon MP Config meta configuration feature.
+This is a Helidon specific feature available since version 2.3.0.
+
+When used, the {spec-name} uses configuration sources and flags configured in the meta configuration file.
 
 The meta-config allows configuration of config sources and other configuration options,
-including retry policies and polling strategies.
+including addition of discovered sources and converters.
 
-If a file named `meta-config.yaml`, or `meta-config.properties` is in the current directory or
-on the classpath and there is no explicit setup of `Config` in the code, the configuration will
+If a file named `mp-meta-config.yaml`, or `mp-meta-config.properties` is in the current directory or
+on the classpath, and there is no explicit setup of configuration in the code, the configuration will
 be loaded from the `meta-config` file.
+The location of the file can be overridden using system property `io.helidon.config.mp.meta-config`,
+    or environment variable `HELIDON_MP_META_CONFIG`
 
 [source,yaml]
 .Example of a YAML meta configuration file:
 ----
+add-discovered-sources: true <1>
+add-discovered-converters: false <2>
+add-default-sources: false <3>
+
 sources:
-  - type: "system-properties" <1>
-  - type: "environment-variables" <2>
-  - type: "file"
-    properties:
-      optional: true
-      path: "mp-config.yaml" <3>
-  - type: "classpath"
-    properties:
-      optional: true
-      resource: application.yaml <4>
-  - type: "classpath"
-      multi-source: true
-    properties:
-      resource: "META-INF/microprofile-config.properties" <5>
-----
+  - type: "environment-variables" <4>
+  - type: "system-properties" <5>
+  - type: "properties" <6>
+    path: "/conf/prod.properties" <7>
+    ordinal: 50 <8>
+    optional: true <9>
+  - type: "yaml"  <10>
+    classpath: "META-INF/database.yaml" <11>
 
-<1> Loads the environment variables config source.
-<2> Loads the system variables config source.
-<3> Loads the file config source from `mp-config.yaml` that is optional.
-<4> Loads the file config source from `application.yaml` that is optional.
-<5> Loads the classpath resource config source for  `microprofile-config.properties` that is the default configuration source of Microprofile application and is mandatory.
+----
 
+<1> If configured to `true`, config sources discovered through service loader will be added
+<2> If configured to `true`, converters discovered through service loader will be added
+<3> If configured to `true`, default config sources (system properties, environment variables, and `META-INF/microprofile-config.properties) will be added
+<4> Loads the environment variables config source.
+<5> Loads the system properties config source.
+<6> Loads a properties file
+<7> Location of the file: `/conf/prod.properties` on the file system
+<8> Custom ordinal, if not defined, the value defined in the file, or default value is used
+<9> The file is optional (if not optional and no file is found, the bootstrap fails)
+<10> Loads a YAML file
+<11> Location of the file: `META-INF/database.yaml` on the classpath
+
+For backward compatibility, we will support usage of Helidon SE meta-configuration until version 3.0.0. Using this approach causes behavior that is not compatible with {spec-name} specification.
 
 == Guides