diff --git a/autotests/kconfigloadertest.cpp b/autotests/kconfigloadertest.cpp
--- a/autotests/kconfigloadertest.cpp
+++ b/autotests/kconfigloadertest.cpp
@@ -54,62 +54,71 @@
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemBool *, "DefaultBoolItem");
 
     QVERIFY(typeItem->isEqual(true));
+    QCOMPARE(typeItem->loadedValue(), true);
 }
 
 void ConfigLoaderTest::colorDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemColor *, "DefaultColorItem");
 
     QVERIFY(typeItem->isEqual(QColor("#00FF00")));
+    QCOMPARE(typeItem->loadedValue(), QVariant::fromValue<QColor>(QColor("#00FF00")));
 }
 
 void ConfigLoaderTest::dateTimeDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemDateTime *, "DefaultDateTimeItem");
 
     QVERIFY(typeItem->isEqual(QDateTime::fromString("Thu Sep 09 2010")));
+    QCOMPARE(typeItem->loadedValue(), QDateTime::fromString("Thu Sep 09 2010"));
 }
 
 void ConfigLoaderTest::enumDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemEnum *, "DefaultEnumItem");
 
     QVERIFY(typeItem->isEqual(3));
+    QCOMPARE(typeItem->loadedValue(), 3);
 }
 
 void ConfigLoaderTest::fontDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemFont *, "DefaultFontItem");
 
     QVERIFY(typeItem->isEqual(QFont("DejaVu Sans")));
+    QCOMPARE(typeItem->loadedValue(), QFont("DejaVu Sans"));
 }
 
 void ConfigLoaderTest::intDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemInt *, "DefaultIntItem");
 
     QVERIFY(typeItem->isEqual(27));
+    QCOMPARE(typeItem->loadedValue(), 27);
 }
 
 void ConfigLoaderTest::passwordDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemPassword *, "DefaultPasswordItem");
 
     QVERIFY(typeItem->isEqual(QString::fromLatin1("h4x.")));
+    QCOMPARE(typeItem->loadedValue(), QString::fromLatin1("h4x."));
 }
 
 void ConfigLoaderTest::pathDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemPath *, "DefaultPathItem");
 
     QVERIFY(typeItem->isEqual(QString::fromLatin1("/dev/null")));
+    QCOMPARE(typeItem->loadedValue(), QString::fromLatin1("/dev/null"));
 }
 
 void ConfigLoaderTest::stringDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KConfigSkeleton::ItemString *, "DefaultStringItem");
 
     QVERIFY(typeItem->isEqual(QString::fromLatin1("TestString")));
+    QCOMPARE(typeItem->loadedValue(), QString::fromLatin1("TestString"));
 }
 
 void ConfigLoaderTest::stringListDefaultValue()
@@ -125,27 +134,31 @@
     expected.append(QStringLiteral("Five"));
 
     QVERIFY(typeItem->isEqual(expected));
+    QCOMPARE(typeItem->loadedValue(), QVariant::fromValue<QStringList>(expected));
 }
 
 void ConfigLoaderTest::uintDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemUInt *, "DefaultUIntItem");
 
     QVERIFY(typeItem->isEqual(7U));
+    QCOMPARE(typeItem->loadedValue(), 7U);
 }
 
 void ConfigLoaderTest::urlDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemUrl *, "DefaultUrlItem");
 
     QVERIFY(typeItem->isEqual(QUrl("http://kde.org")));
+    QCOMPARE(typeItem->loadedValue(), QUrl("http://kde.org"));
 }
 
 void ConfigLoaderTest::doubleDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemDouble *, "DefaultDoubleItem");
 
     QVERIFY(typeItem->isEqual(13.37));
+    QCOMPARE(typeItem->loadedValue(), 13.37);
 }
 
 void ConfigLoaderTest::intListDefaultValue()
@@ -162,20 +175,23 @@
     expected.append(8);
 
     QVERIFY(typeItem->isEqual(QVariant::fromValue(expected)));
+    QCOMPARE(typeItem->loadedValue().value<QList<int>>(), expected);
 }
 
 void ConfigLoaderTest::longLongDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemLongLong *, "DefaultLongLongItem");
 
     QVERIFY(typeItem->isEqual(Q_INT64_C(-9211372036854775808)));
+    QCOMPARE(typeItem->loadedValue(), Q_INT64_C(-9211372036854775808));
 }
 
 void ConfigLoaderTest::pointDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemPoint *, "DefaultPointItem");
 
     QVERIFY(typeItem->isEqual(QPoint(185, 857)));
+    QCOMPARE(typeItem->loadedValue(), QPoint(185, 857));
 }
 
 void ConfigLoaderTest::rectDefaultValue()
@@ -187,20 +203,23 @@
     expected.setCoords(3, 7, 951, 358);
 
     QVERIFY(typeItem->isEqual(expected));
+    QCOMPARE(typeItem->loadedValue(), expected);
 }
 
 void ConfigLoaderTest::sizeDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemSize *, "DefaultSizeItem");
 
     QVERIFY(typeItem->isEqual(QSize(640, 480)));
+    QCOMPARE(typeItem->loadedValue(), QSize(640, 480));
 }
 
 void ConfigLoaderTest::ulongLongDefaultValue()
 {
     GET_CONFIG_ITEM_VALUE(KCoreConfigSkeleton::ItemULongLong *, "DefaultULongLongItem");
 
     QVERIFY(typeItem->isEqual(Q_UINT64_C(9223372036854775806)));
+    QCOMPARE(typeItem->loadedValue(), Q_UINT64_C(9223372036854775806));
 }
 
 QTEST_MAIN(ConfigLoaderTest)
diff --git a/src/core/kcoreconfigskeleton.h b/src/core/kcoreconfigskeleton.h
--- a/src/core/kcoreconfigskeleton.h
+++ b/src/core/kcoreconfigskeleton.h
@@ -243,6 +243,13 @@
      */
     bool isSaveNeeded() const;
 
+    /**
+     * Return the last loaded value of this KConfigSkeletonItem.
+     *
+     * @since 5.68
+     */
+    QVariant loadedValue() const;
+
 protected:
     explicit KConfigSkeletonItem(KConfigSkeletonItemPrivate &dd, const QString &_group, const QString &_key);
 
@@ -260,6 +267,7 @@
     // KF6: Use proper pure virtuals in KConfigSkeletonItem
     void setIsDefaultImpl(const std::function<bool()> &impl);
     void setIsSaveNeededImpl(const std::function<bool()> &impl);
+    void setLoadedValueImpl(const std::function<QVariant()> &impl);
 
     KConfigSkeletonItemPrivate *const d_ptr;
 };
@@ -337,6 +345,7 @@
     {
         setIsDefaultImpl([this] { return mReference == mDefault; });
         setIsSaveNeededImpl([this] { return mReference != mLoadedValue; });
+        setLoadedValueImpl([this] { return QVariant::fromValue<T>(mLoadedValue); });
     }
 
     /**
diff --git a/src/core/kcoreconfigskeleton.cpp b/src/core/kcoreconfigskeleton.cpp
--- a/src/core/kcoreconfigskeleton.cpp
+++ b/src/core/kcoreconfigskeleton.cpp
@@ -180,6 +180,12 @@
     return d->mIsSaveNeededImpl();
 }
 
+QVariant KConfigSkeletonItem::loadedValue() const
+{
+    Q_D(const KConfigSkeletonItem);
+    return d->mLoadedValueImpl();
+}
+
 void KConfigSkeletonItem::readImmutability(const KConfigGroup &group)
 {
     Q_D(KConfigSkeletonItem);
@@ -198,6 +204,12 @@
     d->mIsSaveNeededImpl = impl;
 }
 
+void KConfigSkeletonItem::setLoadedValueImpl(const std::function<QVariant ()> &impl)
+{
+    Q_D(KConfigSkeletonItem);
+    d->mLoadedValueImpl= impl;
+}
+
 KPropertySkeletonItem::KPropertySkeletonItem(QObject *object, const QByteArray &propertyName, const QVariant &defaultValue)
     : KConfigSkeletonItem(*new KPropertySkeletonItemPrivate(object, propertyName, defaultValue), {}, {})
 {
@@ -209,6 +221,10 @@
         Q_D(const KPropertySkeletonItem);
         return d->mReference != d->mLoadedValue;
     });
+    setLoadedValueImpl([this] {
+        Q_D(const KPropertySkeletonItem);
+        return QVariant::fromValue(d->mLoadedValue);
+    });
 }
 
 QVariant KPropertySkeletonItem::property() const
@@ -1554,6 +1570,7 @@
 
     setIsDefaultImpl([this] { return mItem->isDefault(); });
     setIsSaveNeededImpl([this] { return mItem->isSaveNeeded(); });
+    setLoadedValueImpl([this] { return mItem->loadedValue(); });
 }
 
 KConfigCompilerSignallingItem::~KConfigCompilerSignallingItem()
diff --git a/src/core/kcoreconfigskeleton_p.h b/src/core/kcoreconfigskeleton_p.h
--- a/src/core/kcoreconfigskeleton_p.h
+++ b/src/core/kcoreconfigskeleton_p.h
@@ -66,6 +66,7 @@
     // HACK: Necessary to avoid introducing new virtuals in KConfigSkeletonItem
     std::function<bool()> mIsDefaultImpl;
     std::function<bool()> mIsSaveNeededImpl;
+    std::function<QVariant()> mLoadedValueImpl;
 };
 
 class KPropertySkeletonItemPrivate : public KConfigSkeletonItemPrivate