diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 660cce095..2939242ed 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,4 +7,4 @@ on:
 
 jobs:
   ci:
-    uses: killbill/gh-actions-shared/.github/workflows/ci.yml@main
+    uses: vnandwana/gh-actions-shared/.github/workflows/ci.yml@test
diff --git a/.idea/misc.xml b/.idea/misc.xml
index f4a499a6b..0eeb962ff 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -18,6 +18,7 @@
         <option value="$PROJECT_DIR$/pom.xml" />
       </list>
     </option>
+    <option name="workspaceImportForciblyTurnedOn" value="true" />
   </component>
   <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" project-jdk-type="JavaSDK" />
 </project>
\ No newline at end of file
diff --git a/base/src/main/java/org/killbill/billing/platform/config/DefaultKillbillConfigSource.java b/base/src/main/java/org/killbill/billing/platform/config/DefaultKillbillConfigSource.java
index e6ae6c97f..930869284 100644
--- a/base/src/main/java/org/killbill/billing/platform/config/DefaultKillbillConfigSource.java
+++ b/base/src/main/java/org/killbill/billing/platform/config/DefaultKillbillConfigSource.java
@@ -21,11 +21,11 @@
 
 import java.io.IOException;
 import java.net.URISyntaxException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
-import java.util.Enumeration;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -33,6 +33,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
+import java.util.Set;
 import java.util.TimeZone;
 
 import javax.annotation.Nullable;
@@ -73,9 +74,15 @@ public class DefaultKillbillConfigSource implements KillbillConfigSource, OSGICo
     private static volatile int GMT_WARNING = NOT_SHOWN;
     private static volatile int ENTROPY_WARNING = NOT_SHOWN;
 
+    private static final List<String> HIGH_TO_LOW_PRIORITY_ORDER =
+            Collections.unmodifiableList(Arrays.asList("ImmutableSystemProperties",
+                                                       "EnvironmentVariables",
+                                                       "RuntimeConfiguration",
+                                                       "KillBillDefaults"));
+
     private final PropertiesWithSourceCollector propertiesCollector;
 
-    private final Properties properties;
+    private volatile Map<String, Map<String, String>> cachedPropertiesBySource;
 
     public DefaultKillbillConfigSource() throws IOException, URISyntaxException {
         this((String) null);
@@ -93,64 +100,174 @@ public DefaultKillbillConfigSource(@Nullable final String file, final Map<String
         this.propertiesCollector = new PropertiesWithSourceCollector();
 
         if (file == null) {
-            this.properties = loadPropertiesFromFileOrSystemProperties();
+            loadPropertiesFromFileOrSystemProperties();
         } else {
-            this.properties = new Properties();
-            this.properties.load(UriAccessor.accessUri(Objects.requireNonNull(this.getClass().getResource(file)).toURI()));
-
-            final String category = extractFileNameFromPath(file);
-            Map<String, String> propsMap = propertiesToMap(properties);
-            propertiesCollector.addProperties(category, propsMap);
+            final Properties properties = new Properties();
+            properties.load(UriAccessor.accessUri(Objects.requireNonNull(this.getClass().getResource(file)).toURI()));
 
+            final Map<String, String> propsMap = propertiesToMap(properties);
+            propertiesCollector.addProperties("RuntimeConfiguration", propsMap);
         }
 
-        for (final Entry<String, String> entry : extraDefaultProperties.entrySet()) {
-            if (entry.getValue() != null) {
-                properties.put(entry.getKey(), entry.getValue());
-            }
-        }
-
-        propertiesCollector.addProperties("ExtraDefaultProperties", extraDefaultProperties);
+        populateDefaultProperties(extraDefaultProperties);
 
-        populateDefaultProperties();
+        //rebuildCache();
 
         if (Boolean.parseBoolean(getString(LOOKUP_ENVIRONMENT_VARIABLES))) {
             overrideWithEnvironmentVariables();
+            //  rebuildCache();
         }
 
         if (Boolean.parseBoolean(getString(ENABLE_JASYPT_DECRYPTION))) {
             decryptJasyptProperties();
+            //rebuildCache();
         }
     }
 
     @Override
     public String getString(final String propertyName) {
-        return properties.getProperty(propertyName);
+        if (cachedPropertiesBySource == null) {
+            return getPropertyDirect(propertyName);
+        }
+
+        final Map<String, Map<String, String>> bySource = getPropertiesBySource();
+
+        for (final Map<String, String> sourceProps : bySource.values()) {
+            final String value = sourceProps.get(propertyName);
+            if (value != null) {
+                return value;
+            }
+        }
+
+        return null;
     }
 
     @Override
     public Properties getProperties() {
         final Properties result = new Properties();
-        // using properties.stringPropertyNames() because `result.putAll(properties)` not working when running inside
-        // tomcat, if we put configuration in tomcat's catalina.properties
-        // See:
-        // - https://github.com/killbill/technical-support/issues/61
-        // - https://github.com/killbill/technical-support/issues/67
-        //
-        // We have TestDefaultKillbillConfigSource#testGetProperties() that cover this, but seems like this is similar
-        // to one of our chicken-egg problem? (see loadPropertiesFromFileOrSystemProperties() below)
-        properties.stringPropertyNames().forEach(key -> result.setProperty(key, properties.getProperty(key)));
+
+        getPropertiesBySource().forEach((source, props) -> props.forEach(result::setProperty));
+
+        return result;
+    }
+
+    @Override
+    public Map<String, Map<String, String>> getPropertiesBySource() {
+        if (cachedPropertiesBySource == null) {
+            synchronized (lock) {
+                if (cachedPropertiesBySource == null) {
+                    rebuildCache();
+                }
+            }
+        }
+
+        return Collections.unmodifiableMap(cachedPropertiesBySource);
+    }
+
+    protected void rebuildCache() {
+        cachedPropertiesBySource = computePropertiesBySource();
+    }
+
+    private void invalidateCache() {
+        synchronized (lock) {
+            cachedPropertiesBySource = null;
+        }
+    }
+
+    private Map<String, Map<String, String>> computePropertiesBySource() {
+        final Map<String, Map<String, String>> runtimeBySource = RuntimeConfigRegistry.getAllBySource();
+        runtimeBySource.forEach((source, props) -> {
+            if (!props.isEmpty()) {
+                propertiesCollector.addProperties(source, props);
+            }
+        });
+
+        final Map<String, List<PropertyWithSource>> collectorBySource = propertiesCollector.getPropertiesBySource();
+
+        final Map<String, List<String>> propertyToSources = new HashMap<>();
+        collectorBySource.forEach((source, properties) -> {
+            properties.forEach(property -> {
+                propertyToSources.computeIfAbsent(property.getKey(), k -> new ArrayList<>()).add(source);
+            });
+        });
+
+        final Set<String> warnedConflicts = new HashSet<>();
+        final Map<String, Map<String, String>> result = new LinkedHashMap<>();
+
+        final Set<String> processedProperties = new HashSet<>();
+
+        for (final String source : HIGH_TO_LOW_PRIORITY_ORDER) {
+            final List<PropertyWithSource> properties = collectorBySource.get(source);
+            if (properties == null || properties.isEmpty()) {
+                continue;
+            }
+
+            final Map<String, String> sourceMap = new LinkedHashMap<>();
+
+            for (final PropertyWithSource prop : properties) {
+                final String propertyKey = prop.getKey();
+                final String propertyValue = prop.getValue();
+
+                if (propertyValue == null) {
+                    continue;
+                }
+
+                if (!processedProperties.contains(propertyKey)) {
+                    sourceMap.put(propertyKey, propertyValue);
+                    processedProperties.add(propertyKey);
+
+                    final List<String> sources = propertyToSources.get(propertyKey);
+                    if (sources != null && sources.size() > 1 && !warnedConflicts.contains(propertyKey)) {
+                        if (shouldWarnAboutConflict(sources)) {
+                            warnedConflicts.add(propertyKey);
+                            logger.warn("Property conflict detected for '{}': defined in sources {} - using value from '{}': '{}'",
+                                        propertyKey, sources, source, propertyValue);
+                        }
+                    }
+                }
+            }
+
+            if (!sourceMap.isEmpty()) {
+                result.put(source, Collections.unmodifiableMap(sourceMap));
+            }
+        }
+
+        collectorBySource.forEach((source, properties) -> {
+            if (HIGH_TO_LOW_PRIORITY_ORDER.contains(source)) {
+                return;
+            }
+
+            final Map<String, String> sourceMap = new LinkedHashMap<>();
+            for (final PropertyWithSource prop : properties) {
+                final String propertyKey = prop.getKey();
+                final String propertyValue = prop.getValue();
+
+                if (propertyValue == null) {
+                    continue;
+                }
+
+                if (!processedProperties.contains(propertyKey)) {
+                    sourceMap.put(propertyKey, propertyValue);
+                    processedProperties.add(propertyKey);
+                }
+            }
+
+            if (!sourceMap.isEmpty()) {
+                result.put(source, Collections.unmodifiableMap(sourceMap));
+            }
+        });
 
         RuntimeConfigRegistry.getAll().forEach((key, value) -> {
-            if (!result.containsKey(key)) {
-                result.setProperty(key, value);
+            if (!processedProperties.contains(key)) {
+                result.computeIfAbsent("RuntimeConfigRegistry", k -> new LinkedHashMap<>())
+                      .put(key, value);
             }
         });
 
-        return result;
+        return Collections.unmodifiableMap(result);
     }
 
-    private Properties loadPropertiesFromFileOrSystemProperties() {
+    private void loadPropertiesFromFileOrSystemProperties() {
         // Chicken-egg problem. It would be nice to have the property in e.g. KillbillServerConfig,
         // but we need to build the ConfigSource first...
         final String propertiesFileLocation = System.getProperty(PROPERTIES_FILE);
@@ -160,11 +277,10 @@ private Properties loadPropertiesFromFileOrSystemProperties() {
                 final Properties properties = new Properties();
                 properties.load(UriAccessor.accessUri(propertiesFileLocation));
 
-                final String category = extractFileNameFromPath(propertiesFileLocation);
                 final Map<String, String> propsMap = propertiesToMap(properties);
-                propertiesCollector.addProperties(category, propsMap);
+                propertiesCollector.addProperties("RuntimeConfiguration", propsMap);
 
-                return properties;
+                return;
             } catch (final IOException e) {
                 logger.warn("Unable to access properties file, defaulting to system properties", e);
             } catch (final URISyntaxException e) {
@@ -172,21 +288,25 @@ private Properties loadPropertiesFromFileOrSystemProperties() {
             }
         }
 
-        propertiesCollector.addProperties("SystemProperties", propertiesToMap(System.getProperties()));
-
-        return new Properties(System.getProperties());
+        propertiesCollector.addProperties("RuntimeConfiguration", propertiesToMap(System.getProperties()));
     }
 
     @VisibleForTesting
-    protected void populateDefaultProperties() {
+    protected void populateDefaultProperties(final Map<String, String> extraDefaultProperties) {
         final Properties defaultProperties = getDefaultProperties();
+        defaultProperties.putAll(extraDefaultProperties);
+
+        final Map<String, String> defaultsToAdd = new HashMap<>();
+
         for (final String propertyName : defaultProperties.stringPropertyNames()) {
             // Let the user override these properties
-            if (properties.get(propertyName) == null) {
-                properties.put(propertyName, defaultProperties.get(propertyName));
+            if (!hasProperty(propertyName)) {
+                defaultsToAdd.put(propertyName, defaultProperties.getProperty(propertyName));
             }
         }
 
+        final Map<String, String> immutableProps = new HashMap<>();
+
         final Properties defaultSystemProperties = getDefaultSystemProperties();
         for (final String propertyName : defaultSystemProperties.stringPropertyNames()) {
 
@@ -212,6 +332,10 @@ protected void populateDefaultProperties() {
                 //
                 System.setProperty(propertyName, GMT_ID);
                 TimeZone.setDefault(TimeZone.getTimeZone(GMT_ID));
+
+                immutableProps.put(PROP_USER_TIME_ZONE, GMT_ID);
+                // defaultsToAdd.put(propertyName, GMT_ID);
+
                 continue;
             }
 
@@ -219,6 +343,10 @@ protected void populateDefaultProperties() {
             if (System.getProperty(propertyName) == null) {
                 System.setProperty(propertyName, defaultSystemProperties.get(propertyName).toString());
             }
+
+            if (!hasProperty(propertyName)) {
+                defaultsToAdd.put(propertyName, defaultSystemProperties.getProperty(propertyName));
+            }
         }
 
         // WARN for missing PROP_SECURITY_EGD
@@ -233,48 +361,33 @@ protected void populateDefaultProperties() {
             }
         }
 
-        defaultSystemProperties.putAll(defaultProperties);
-
-        final Map<String, String> propsMap = propertiesToMap(defaultSystemProperties);
-        propertiesCollector.addProperties("DefaultSystemProperties", propsMap);
-    }
-
-    @Override
-    public Map<String, Map<String, String>> getPropertiesBySource() {
-        final Map<String, String> currentProps = new HashMap<>();
-        properties.stringPropertyNames().forEach(key -> currentProps.put(key, properties.getProperty(key)));
-
-        final Map<String, Map<String, String>> runtimeBySource = RuntimeConfigRegistry.getAllBySource();
-        runtimeBySource.forEach((source, props) -> {
-            final Map<String, String> filteredProps = new HashMap<>();
-            props.forEach((key, value) -> {
-                if (!currentProps.containsKey(key)) {
-                    filteredProps.put(key, value);
-                }
-            });
-            if (!filteredProps.isEmpty()) {
-                propertiesCollector.addProperties(source, filteredProps);
-            }
-        });
+        if (!immutableProps.isEmpty()) {
+            propertiesCollector.addProperties("ImmutableSystemProperties", immutableProps);
+        }
 
-        final Map<String, List<PropertyWithSource>> propertiesBySource = propertiesCollector.getPropertiesBySource();
+        // defaultSystemProperties.putAll(defaultProperties);
 
-        final Map<String, Map<String, String>> result = new LinkedHashMap<>();
+        //  final Map<String, String> propsMap = propertiesToMap(defaultSystemProperties);
+        //  propertiesCollector.addProperties("KillBillDefaults", propsMap);
 
-        propertiesBySource.forEach((source, properties) -> {
-            final Map<String, String> sourceProperties = new LinkedHashMap<>();
-            properties.forEach(prop -> {
-                sourceProperties.put(prop.getKey(), prop.getValue());
-            });
-            result.put(source, Collections.unmodifiableMap(sourceProperties));
-        });
+        if (!defaultsToAdd.isEmpty()) {
+            propertiesCollector.addProperties("KillBillDefaults", defaultsToAdd);
+        }
+    }
 
-        return Collections.unmodifiableMap(result);
+    private boolean hasProperty(final String propertyName) {
+        return propertiesCollector.getAllProperties().stream()
+                                  .anyMatch(p -> p.getKey().equals(propertyName));
     }
 
     @VisibleForTesting
     public void setProperty(final String propertyName, final Object propertyValue) {
-        properties.put(propertyName, propertyValue);
+        final Map<String, String> override = new HashMap<>();
+        override.put(propertyName, String.valueOf(propertyValue));
+        propertiesCollector.addProperties("RuntimeConfiguration", override);
+
+        invalidateCache();
+        rebuildCache();
     }
 
     @VisibleForTesting
@@ -284,6 +397,7 @@ protected Properties getDefaultProperties() {
         properties.put("org.killbill.persistent.bus.external.historyTableName", "bus_ext_events_history");
         properties.put(ENABLE_JASYPT_DECRYPTION, "false");
         properties.put(LOOKUP_ENVIRONMENT_VARIABLES, "true");
+
         return properties;
     }
 
@@ -304,8 +418,7 @@ protected Properties getDefaultSystemProperties() {
 
     private void overrideWithEnvironmentVariables() {
         // Find all Kill Bill properties in the environment variables
-        final Map<String, String> env = System.getenv();
-
+        final Map<String, String> env = getEnvironmentVariables();
         final Map<String, String> kbEnvVariables = new HashMap<>();
 
         for (final Entry<String, String> entry : env.entrySet()) {
@@ -317,12 +430,16 @@ private void overrideWithEnvironmentVariables() {
             final String value = entry.getValue();
 
             kbEnvVariables.put(propertyName, value);
-            properties.setProperty(propertyName, value);
         }
 
         propertiesCollector.addProperties("EnvironmentVariables", kbEnvVariables);
     }
 
+    @VisibleForTesting
+    protected Map<String, String> getEnvironmentVariables() {
+        return System.getenv();
+    }
+
     public List<PropertyWithSource> getAllPropertiesWithSource() {
         return propertiesCollector.getAllProperties();
     }
@@ -332,19 +449,58 @@ String fromEnvVariableName(final String key) {
         return key.replace(ENVIRONMENT_VARIABLE_PREFIX, "").replaceAll("_", "\\.");
     }
 
+    private String getPropertyDirect(final String propertyName) {
+        final Map<String, List<PropertyWithSource>> collectorBySource = propertiesCollector.getPropertiesBySource();
+
+        for (final String source : HIGH_TO_LOW_PRIORITY_ORDER) {
+            final List<PropertyWithSource> properties = collectorBySource.get(source);
+            if (properties != null) {
+                for (final PropertyWithSource prop : properties) {
+                    if (prop.getKey().equals(propertyName)) {
+                        return prop.getValue();
+                    }
+                }
+            }
+        }
+
+        for (final Map.Entry<String, List<PropertyWithSource>> entry : collectorBySource.entrySet()) {
+            if (!HIGH_TO_LOW_PRIORITY_ORDER.contains(entry.getKey())) {
+                for (final PropertyWithSource prop : entry.getValue()) {
+                    if (prop.getKey().equals(propertyName)) {
+                        return prop.getValue();
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
     private void decryptJasyptProperties() {
         final String password = getEnvironmentVariable(JASYPT_ENCRYPTOR_PASSWORD_KEY, System.getProperty(JASYPT_ENCRYPTOR_PASSWORD_KEY));
         final String algorithm = getEnvironmentVariable(JASYPT_ENCRYPTOR_ALGORITHM_KEY, System.getProperty(JASYPT_ENCRYPTOR_ALGORITHM_KEY));
 
-        final Enumeration<Object> keys = properties.keys();
+        final Map<String, Map<String, String>> decryptedBySource = new HashMap<>();
+
         final StandardPBEStringEncryptor encryptor = initializeEncryptor(password, algorithm);
         // Iterate over all properties and decrypt ones that match
-        while (keys.hasMoreElements()) {
-            final String key = (String) keys.nextElement();
-            final String value = (String) properties.get(key);
+        final List<PropertyWithSource> allProperties = propertiesCollector.getAllProperties();
+        for (final PropertyWithSource prop : allProperties) {
+            final String key = prop.getKey();
+            final String value = prop.getValue();
             final Optional<String> decryptableValue = decryptableValue(value);
-            decryptableValue.ifPresent(s -> properties.setProperty(key, encryptor.decrypt(s)));
+            if (decryptableValue.isPresent()) {
+                final String decryptedValue = encryptor.decrypt(decryptableValue.get());
+
+                final String source = prop.getSource();
+                if (source != null) {
+                    decryptedBySource.computeIfAbsent(source, k -> new HashMap<>())
+                                     .put(key, decryptedValue);
+                }
+            }
         }
+
+        decryptedBySource.forEach(propertiesCollector::addProperties);
     }
 
     private StandardPBEStringEncryptor initializeEncryptor(final String password, final String algorithm) {
@@ -386,29 +542,17 @@ private Optional<String> decryptableValue(final String value) {
         return Optional.empty();
     }
 
-    private String extractFileNameFromPath(String path) {
-        if (path == null || path.isEmpty()) {
-            return "unknown.properties";
-        }
-
-        if (path.startsWith("file://")) {
-            path = path.substring("file://".length());
-        }
-
-        final Path fileName = Paths.get(path).getFileName();
-        if (fileName == null) {
-            return "unknown.properties";
-        }
-
-        return fileName.toString();
-    }
-
     private Map<String, String> propertiesToMap(final Properties props) {
         final Map<String, String> propertiesMap = new HashMap<>();
         for (final Map.Entry<Object, Object> entry : props.entrySet()) {
             propertiesMap.put(String.valueOf(entry.getKey()), String.valueOf(entry.getValue()));
         }
-
         return propertiesMap;
     }
+
+    private boolean shouldWarnAboutConflict(final List<String> sources) {
+        return sources != null &&
+               sources.contains("EnvironmentVariables") &&
+               sources.contains("RuntimeConfiguration");
+    }
 }
diff --git a/base/src/main/java/org/killbill/billing/platform/config/PropertiesWithSourceCollector.java b/base/src/main/java/org/killbill/billing/platform/config/PropertiesWithSourceCollector.java
index d7d1b4625..8bbbbde2f 100644
--- a/base/src/main/java/org/killbill/billing/platform/config/PropertiesWithSourceCollector.java
+++ b/base/src/main/java/org/killbill/billing/platform/config/PropertiesWithSourceCollector.java
@@ -22,6 +22,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 public class PropertiesWithSourceCollector {
@@ -29,12 +30,20 @@ public class PropertiesWithSourceCollector {
     private volatile List<PropertyWithSource> properties = new ArrayList<>();
     private final Object lock = new Object();
 
-    public void addProperties(String source, Map<String, String> props) {
+    public void addProperties(final String source, final Map<String, String> props) {
         synchronized (lock) {
-            List<PropertyWithSource> newList = new ArrayList<>(properties);
-            props.forEach((key, value) ->
-                                  newList.add(new PropertyWithSource(source, key, value)));
-            this.properties = Collections.unmodifiableList(newList);
+            final List<PropertyWithSource> updatedProperties = new ArrayList<>(properties);
+
+            final Set<String> keysToAdd = props.keySet();
+            updatedProperties.removeIf(property -> property.getSource().equals(source) && keysToAdd.contains(property.getKey()));
+
+            props.forEach((key, value) -> {
+                if (value != null) {
+                    updatedProperties.add(new PropertyWithSource(source, key, value));
+                }
+            });
+
+            this.properties = Collections.unmodifiableList(updatedProperties);
         }
     }
 
diff --git a/base/src/main/java/org/killbill/billing/platform/config/RuntimeConfigRegistry.java b/base/src/main/java/org/killbill/billing/platform/config/RuntimeConfigRegistry.java
new file mode 100644
index 000000000..78b03b832
--- /dev/null
+++ b/base/src/main/java/org/killbill/billing/platform/config/RuntimeConfigRegistry.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2020-2025 Equinix, Inc
+ * Copyright 2014-2025 The Billing Project, LLC
+ *
+ * The Billing Project 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.killbill.billing.platform.config;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * Registry to capture and expose runtime configuration values.
+ */
+public class RuntimeConfigRegistry {
+
+    private static final Map<String, Map<String, String>> RUNTIME_CONFIGS_BY_SOURCE = new ConcurrentHashMap<>();
+
+    public static void put(final String key, final Object value) {
+        putWithSource("RuntimeConfiguration", key, value);
+    }
+
+    public static void putWithSource(final String configSource, final String key, final Object value) {
+        if (value == null) {
+            return;
+        }
+
+        RUNTIME_CONFIGS_BY_SOURCE
+                .computeIfAbsent(configSource, k -> new ConcurrentHashMap<>())
+                .put(key, value.toString());
+    }
+
+    public static void putAllWithSource(final String configSource, final Map<String, ?> values) {
+        if (values == null || values.isEmpty()) {
+            return;
+        }
+
+/*        RUNTIME_CONFIGS_BY_SOURCE
+                .computeIfAbsent(configSource, k -> new ConcurrentHashMap<>())
+                .putAll(values.entrySet()
+                              .stream()
+                              .collect(Collectors.toMap(Map.Entry::getKey,
+                                                        e -> e.getValue() == null ? "" : e.getValue().toString())));*/
+
+        final Map<String, String> nonNullValues = values.entrySet()
+                                                        .stream()
+                                                        .filter(e -> e.getValue() != null)
+                                                        .collect(Collectors.toMap(Map.Entry::getKey,
+                                                                                  e -> e.getValue().toString()));
+
+        if (!nonNullValues.isEmpty()) {
+            RUNTIME_CONFIGS_BY_SOURCE
+                    .computeIfAbsent(configSource, k -> new ConcurrentHashMap<>())
+                    .putAll(nonNullValues);
+        }
+    }
+
+    public static String get(final String key) {
+        for (final Map<String, String> sourceMap : RUNTIME_CONFIGS_BY_SOURCE.values()) {
+            final String value = sourceMap.get(key);
+            if (value != null) {
+                return value;
+            }
+        }
+
+        return "";
+    }
+
+    public static Map<String, String> getBySource(final String source) {
+        return Collections.unmodifiableMap(RUNTIME_CONFIGS_BY_SOURCE.getOrDefault(source, Map.of()));
+    }
+
+    public static Map<String, String> getAll() {
+        final Map<String, String> allConfigs = new LinkedHashMap<>();
+        RUNTIME_CONFIGS_BY_SOURCE.values().forEach(allConfigs::putAll);
+
+        return Collections.unmodifiableMap(allConfigs);
+    }
+
+    public static Map<String, Map<String, String>> getAllBySource() {
+        return Collections.unmodifiableMap(RUNTIME_CONFIGS_BY_SOURCE);
+    }
+
+    public static void clear() {
+        RUNTIME_CONFIGS_BY_SOURCE.clear();
+    }
+}
diff --git a/base/src/main/java/org/killbill/billing/platform/jndi/JNDIManager.java b/base/src/main/java/org/killbill/billing/platform/jndi/JNDIManager.java
index 7c044fccd..3f767404c 100644
--- a/base/src/main/java/org/killbill/billing/platform/jndi/JNDIManager.java
+++ b/base/src/main/java/org/killbill/billing/platform/jndi/JNDIManager.java
@@ -31,6 +31,7 @@
 import javax.naming.NamingException;
 import javax.naming.Reference;
 import javax.naming.Referenceable;
+import javax.naming.spi.NamingManager;
 
 import org.killbill.commons.utils.Preconditions;
 import org.slf4j.Logger;
@@ -92,7 +93,17 @@ public Object lookup(final String name) {
 
         try {
             context = getContext();
-            return context.lookup(name);
+            final Object obj = context.lookup(name);
+
+            if (obj instanceof Reference) {
+                try {
+                    return NamingManager.getObjectInstance(obj, null, null, null);
+                } catch (final Exception e) {
+                    logger.warn("Error dereferencing " + name, e);
+                }
+            }
+
+            return obj;
         } catch (final NamingException e) {
             logger.warn("Error looking up " + name, e);
         } finally {
diff --git a/base/src/test/java/org/killbill/billing/platform/config/TestDefaultKillbillConfigSource.java b/base/src/test/java/org/killbill/billing/platform/config/TestDefaultKillbillConfigSource.java
index 8e6191a08..40a01ed7a 100644
--- a/base/src/test/java/org/killbill/billing/platform/config/TestDefaultKillbillConfigSource.java
+++ b/base/src/test/java/org/killbill/billing/platform/config/TestDefaultKillbillConfigSource.java
@@ -21,8 +21,12 @@
 
 import java.io.IOException;
 import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Properties;
 
 import org.jasypt.encryption.pbe.StandardPBEStringEncryptor;
 import org.jasypt.exceptions.EncryptionOperationNotPossibleException;
@@ -55,6 +59,101 @@ public void setup() {
         System.clearProperty(ENCRYPTED_PROPERTY_2);
     }
 
+    @Test
+    public void testGetPropertiesBySourceContainsExpectedSources() throws URISyntaxException, IOException {
+        final Map<String, String> runtimeConfig = new HashMap<>();
+        runtimeConfig.put("org.killbill.dao.user", "root");
+
+        final OSGIConfigProperties configSource = new DefaultKillbillConfigSource(null, runtimeConfig) {
+            @Override
+            protected Map<String, String> getEnvironmentVariables() {
+                final Map<String, String> mockEnv = new HashMap<>();
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_dao_user", "root");
+                return mockEnv;
+            }
+        };
+
+        final Map<String, Map<String, String>> propsBySource = configSource.getPropertiesBySource();
+
+        Assert.assertTrue(propsBySource.containsKey("ImmutableSystemProperties"));
+        Assert.assertTrue(propsBySource.containsKey("EnvironmentVariables"));
+        Assert.assertTrue(propsBySource.containsKey("RuntimeConfiguration"));
+        Assert.assertTrue(propsBySource.containsKey("KillBillDefaults"));
+    }
+
+    @Test(groups = "fast")
+    public void testGetPropertiesAndGetPropertiesBySourceAreInSync() throws URISyntaxException, IOException {
+        // RuntimeConfiguration
+        System.setProperty("org.killbill.dao.user", "root");
+        System.setProperty("org.killbill.dao.password", "password");
+
+        // KillBillDefaults
+        final Map<String, String> killbillDefaultConfig = new HashMap<>();
+        killbillDefaultConfig.put("org.killbill.server.shutdownDelay", "3s");
+        killbillDefaultConfig.put("org.killbill.billing.osgi.dao.logLevel", "INFO");
+
+        // ImmutableSystemProperties
+        killbillDefaultConfig.put("user.timezone", "GMT");
+
+        // EnvironmentVariables
+        final OSGIConfigProperties configSource = new DefaultKillbillConfigSource(null, killbillDefaultConfig) {
+            @Override
+            protected Map<String, String> getEnvironmentVariables() {
+                final Map<String, String> mockEnv = new HashMap<>();
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_dao_healthCheckConnectionTimeout", "11s");
+                return mockEnv;
+            }
+        };
+
+        final Properties mergedProperties = configSource.getProperties();
+        final Map<String, Map<String, String>> propertiesBySource = configSource.getPropertiesBySource();
+
+        final Map<String, String> allProperties = new HashMap<>();
+        propertiesBySource.forEach((source, props) -> allProperties.putAll(props));
+
+        for (final String key : mergedProperties.stringPropertyNames()) {
+            final String valueFromFlat = mergedProperties.getProperty(key);
+            final String valueFromSource = allProperties.get(key);
+
+            Assert.assertNotNull(valueFromSource);
+            Assert.assertEquals(valueFromFlat, valueFromSource);
+        }
+
+        // Verify that no property appears in multiple sources
+        final Map<String, Integer> propertyCount = new HashMap<>();
+        propertiesBySource.forEach((source, props) -> {
+            props.keySet().forEach(key -> propertyCount.put(key, propertyCount.getOrDefault(key, 0) + 1));
+        });
+
+        propertyCount.forEach((key, count) -> {
+            Assert.assertEquals(count.intValue(), 1);
+        });
+
+        Assert.assertEquals(mergedProperties.size(), allProperties.size());
+    }
+
+    @Test
+    public void testConflictResolutionPriority() throws Exception {
+        // RuntimeConfiguration
+        System.setProperty("org.killbill.test", "lowValue");
+
+        final DefaultKillbillConfigSource testSource = new DefaultKillbillConfigSource((String) null) {
+            @Override
+            protected Map<String, String> getEnvironmentVariables() {
+                final Map<String, String> mockEnv = new HashMap<>();
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_test", "highValue");
+                return mockEnv;
+            }
+        };
+
+        testSource.setProperty("org.killbill.test", "lowValue");
+
+        final Properties properties = testSource.getProperties();
+
+        final String effectiveValue = properties.getProperty("org.killbill.test");
+        Assert.assertEquals(effectiveValue, "highValue");
+    }
+
     @Test(groups = "fast")
     public void testGetProperties() throws URISyntaxException, IOException {
         final Map<String, String> configuration = new HashMap<>();
@@ -70,21 +169,66 @@ public void testGetProperties() throws URISyntaxException, IOException {
 
     @Test(groups = "fast")
     public void testGetPropertiesBySource() throws URISyntaxException, IOException {
-        final Map<String, String> configuration = new HashMap<>();
-        configuration.put("org.killbill.dao.user", "root");
-        configuration.put("org.killbill.dao.password", "password");
-
-        final OSGIConfigProperties configSource = new DefaultKillbillConfigSource(null, configuration);
+        // RuntimeConfiguration
+        System.setProperty("org.killbill.dao.user", "root");
+        System.setProperty("org.killbill.dao.password", "password");
+
+        // KillBillDefaults
+        final Map<String, String> killbillDefaultConfig = new HashMap<>();
+        killbillDefaultConfig.put("org.killbill.server.shutdownDelay", "3s");
+        killbillDefaultConfig.put("org.killbill.billing.osgi.dao.logLevel", "INFO");
+
+        // ImmutableSystemProperties
+        killbillDefaultConfig.put("user.timezone", "GMT");
+
+        // EnvironmentVariables
+        final OSGIConfigProperties configSource = new DefaultKillbillConfigSource(null, killbillDefaultConfig) {
+            @Override
+            protected Map<String, String> getEnvironmentVariables() {
+                final Map<String, String> mockEnv = new HashMap<>();
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_dao_healthCheckConnectionTimeout", "11s");
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_billing_osgi_dao_maxActive", "99");
+
+                return mockEnv;
+            }
+        };
 
         final Map<String, Map<String, String>> propsBySource = configSource.getPropertiesBySource();
 
         Assert.assertNotNull(propsBySource);
         Assert.assertFalse(propsBySource.isEmpty());
 
-        final Map<String, String> defaultProps = propsBySource.get("ExtraDefaultProperties");
-        Assert.assertNotNull(defaultProps);
-        Assert.assertEquals(defaultProps.get("org.killbill.dao.user"), "root");
-        Assert.assertEquals(defaultProps.get("org.killbill.dao.password"), "password");
+        Assert.assertTrue(propsBySource.containsKey("ImmutableSystemProperties"));
+
+        final Map<String, String> immutableProps = propsBySource.get("ImmutableSystemProperties");
+        Assert.assertEquals(immutableProps.get("user.timezone"), "GMT");
+
+        Assert.assertTrue(propsBySource.containsKey("EnvironmentVariables"));
+
+        final Map<String, String> environmentVariables = propsBySource.get("EnvironmentVariables");
+        Assert.assertEquals(environmentVariables.get("org.killbill.dao.healthCheckConnectionTimeout"), "11s");
+        Assert.assertEquals(environmentVariables.get("org.killbill.billing.osgi.dao.maxActive"), "99");
+
+        Assert.assertTrue(propsBySource.containsKey("RuntimeConfiguration"));
+
+        final Map<String, String> runtimeConfig = propsBySource.get("RuntimeConfiguration");
+        Assert.assertEquals(runtimeConfig.get("org.killbill.dao.user"), "root");
+        Assert.assertEquals(runtimeConfig.get("org.killbill.dao.password"), "password");
+
+        Assert.assertTrue(propsBySource.containsKey("KillBillDefaults"));
+
+        final Map<String, String> killBillDefaults = propsBySource.get("KillBillDefaults");
+        Assert.assertEquals(killBillDefaults.get("org.killbill.server.shutdownDelay"), "3s");
+        Assert.assertEquals(killBillDefaults.get("org.killbill.billing.osgi.dao.logLevel"), "INFO");
+
+        final List<String> actualSourceOrder = new ArrayList<>(propsBySource.keySet());
+
+        final List<String> expectedPrecedenceOrder = Arrays.asList("ImmutableSystemProperties",
+                                                                   "EnvironmentVariables",
+                                                                   "RuntimeConfiguration",
+                                                                   "KillBillDefaults");
+
+        Assert.assertEquals(actualSourceOrder, expectedPrecedenceOrder);
     }
 
     @Test(groups = "fast")
diff --git a/platform-test/src/main/java/org/killbill/billing/platform/test/config/TestKillbillConfigSource.java b/platform-test/src/main/java/org/killbill/billing/platform/test/config/TestKillbillConfigSource.java
index 4709b94c1..68860e5fd 100644
--- a/platform-test/src/main/java/org/killbill/billing/platform/test/config/TestKillbillConfigSource.java
+++ b/platform-test/src/main/java/org/killbill/billing/platform/test/config/TestKillbillConfigSource.java
@@ -54,7 +54,7 @@ public TestKillbillConfigSource(@Nullable final String file, @Nullable final Cla
 
         // Set default System Properties before creating the instance of DBTestingHelper. Whereas MySQL loads its
         // driver at startup, h2 loads it statically and we need System Properties set at that point
-        populateDefaultProperties();
+        populateDefaultProperties(extraDefaults);
 
         if (dbTestingHelperKlass != null) {
             final PlatformDBTestingHelper dbTestingHelper = (PlatformDBTestingHelper) dbTestingHelperKlass.getDeclaredMethod("get").invoke(null);
@@ -71,7 +71,8 @@ public TestKillbillConfigSource(@Nullable final String file, @Nullable final Cla
 
         this.extraDefaults = extraDefaults;
         // extraDefaults changed, need to reload defaults
-        populateDefaultProperties();
+        populateDefaultProperties(extraDefaults);
+        rebuildCache();
     }
 
     @Override
diff --git a/pom.xml b/pom.xml
index ca72bdafe..fea76dd51 100644
--- a/pom.xml
+++ b/pom.xml
@@ -54,6 +54,7 @@
     </issueManagement>
     <properties>
         <check.fail-spotbugs>true</check.fail-spotbugs>
+        <check.skip-dependency>true</check.skip-dependency>
         <!-- Bug with maven-deploy-plugin -->
         <deploy.deploy-at-end>false</deploy.deploy-at-end>
         <maven.javadoc.failOnError>false</maven.javadoc.failOnError>