diff --git a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentEntity.cs b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentEntity.cs
index 60b9cb629..d67af9d37 100644
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentEntity.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/MongoContentEntity.cs
@@ -18,7 +18,6 @@ using Squidex.Infrastructure.States;
 
 namespace Squidex.Domain.Apps.Entities.MongoDb.Contents
 {
-    [BsonIgnoreExtraElements]
     public sealed class MongoContentEntity : IContentEntity, IVersionedEntity<DomainId>
     {
         [BsonId]
diff --git a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/Operations/Extensions.cs b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/Operations/Extensions.cs
index 2b8d43e36..62379d476 100644
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/Operations/Extensions.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Contents/Operations/Extensions.cs
@@ -16,7 +16,6 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents.Operations
 {
     public static class Extensions
     {
-        [BsonIgnoreExtraElements]
         public sealed class StatusOnly
         {
             [BsonId]
@@ -36,13 +35,13 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Contents.Operations
             public Status Status { get; set; }
         }
 
-        [BsonIgnoreExtraElements]
         public sealed class IdOnly
         {
             [BsonId]
             [BsonElement("_id")]
             public DomainId Id { get; set; }
 
+            [BsonElement(nameof(Joined))]
             public MongoContentEntity[] Joined { get; set; }
         }
 
diff --git a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/MongoCountEntity.cs b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/MongoCountEntity.cs
index 5e5b993e5..0cf5a9899 100644
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/MongoCountEntity.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/MongoCountEntity.cs
@@ -13,13 +13,15 @@ namespace Squidex.Domain.Apps.Entities.MongoDb
     internal sealed class MongoCountEntity
     {
         [BsonId]
-        [BsonRequired]
+        [BsonElement("_id")]
         public string Key { get; set; }
 
-        [BsonElement]
+        [BsonRequired]
+        [BsonElement(nameof(Count))]
         public long Count { get; set; }
 
-        [BsonElement]
+        [BsonRequired]
+        [BsonElement(nameof(Created))]
         public Instant Created { get; set; }
     }
 }
diff --git a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Rules/MongoRuleEventEntity.cs b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Rules/MongoRuleEventEntity.cs
index 65d29fb16..ab5669e02 100644
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Rules/MongoRuleEventEntity.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Rules/MongoRuleEventEntity.cs
@@ -17,58 +17,57 @@ using Squidex.Infrastructure.Reflection;
 
 namespace Squidex.Domain.Apps.Entities.MongoDb.Rules
 {
-    [BsonIgnoreExtraElements]
     public sealed class MongoRuleEventEntity : IRuleEventEntity
     {
         [BsonId]
-        [BsonElement]
+        [BsonElement("_id")]
         public DomainId JobId { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(AppId))]
         public DomainId AppId { get; set; }
 
         [BsonIgnoreIfDefault]
-        [BsonElement]
+        [BsonElement(nameof(RuleId))]
         public DomainId RuleId { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Created))]
         public Instant Created { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(LastModified))]
         public Instant LastModified { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Result))]
         [BsonRepresentation(BsonType.String)]
         public RuleResult Result { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(JobResult))]
         [BsonRepresentation(BsonType.String)]
         public RuleJobResult JobResult { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Job))]
         [BsonJson]
         public RuleJob Job { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(LastDump))]
         public string? LastDump { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(NumCalls))]
         public int NumCalls { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Expires))]
         public Instant Expires { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(NextAttempt))]
         public Instant? NextAttempt { get; set; }
 
         DomainId IWithId<DomainId>.Id
diff --git a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Schemas/MongoSchemasHashEntity.cs b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Schemas/MongoSchemasHashEntity.cs
index 9c8804e9c..3b418fcb6 100644
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Schemas/MongoSchemasHashEntity.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Schemas/MongoSchemasHashEntity.cs
@@ -11,11 +11,10 @@ using Squidex.Infrastructure;
 
 namespace Squidex.Domain.Apps.Entities.MongoDb.Schemas
 {
-    [BsonIgnoreExtraElements]
     public sealed class MongoSchemasHashEntity
     {
         [BsonId]
-        [BsonElement]
+        [BsonElement("_id")]
         public DomainId AppId { get; set; }
 
         [BsonRequired]
diff --git a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Text/MongoTextIndexBase.cs b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Text/MongoTextIndexBase.cs
index a7b59d0f6..58f94ecdb 100644
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Text/MongoTextIndexBase.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Text/MongoTextIndexBase.cs
@@ -24,12 +24,10 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Text
         {
             [BsonId]
             [BsonElement]
-            [BsonRepresentation(BsonType.String)]
             public string Id { get; set; }
 
             [BsonRequired]
             [BsonElement("_ci")]
-            [BsonRepresentation(BsonType.String)]
             public DomainId ContentId { get; set; }
 
             [BsonIgnoreIfDefault]
diff --git a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Text/MongoTextIndexEntity.cs b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Text/MongoTextIndexEntity.cs
index d70010591..bb42b0ff4 100644
--- a/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Text/MongoTextIndexEntity.cs
+++ b/backend/src/Squidex.Domain.Apps.Entities.MongoDb/Text/MongoTextIndexEntity.cs
@@ -16,12 +16,11 @@ namespace Squidex.Domain.Apps.Entities.MongoDb.Text
     public sealed class MongoTextIndexEntity<T>
     {
         [BsonId]
-        [BsonElement]
-        [BsonRepresentation(BsonType.String)]
+        [BsonElement("_id")]
         public string Id { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(DocId))]
         public string DocId { get; set; }
 
         [BsonRequired]
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/Caching/MongoCacheEntry.cs b/backend/src/Squidex.Infrastructure.MongoDb/Caching/MongoCacheEntry.cs
index 7c72dbd80..07c2927f4 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/Caching/MongoCacheEntry.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/Caching/MongoCacheEntry.cs
@@ -12,12 +12,15 @@ namespace Squidex.Infrastructure.Caching
     public sealed class MongoCacheEntry
     {
         [BsonId]
+        [BsonElement("_id")]
         public string Key { get; set; }
 
-        [BsonElement]
+        [BsonRequired]
+        [BsonElement(nameof(Expires))]
         public DateTime Expires { get; set; }
 
-        [BsonElement]
+        [BsonRequired]
+        [BsonElement(nameof(Value))]
         public byte[] Value { get; set; }
     }
 }
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEvent.cs b/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEvent.cs
index c75a6c8d0..2e23e60b8 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEvent.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEvent.cs
@@ -6,7 +6,6 @@
 // ==========================================================================
 
 using MongoDB.Bson.Serialization.Attributes;
-using Squidex.Infrastructure.MongoDb;
 
 namespace Squidex.Infrastructure.EventSourcing
 {
@@ -17,10 +16,11 @@ namespace Squidex.Infrastructure.EventSourcing
         public string Type { get; set; }
 
         [BsonRequired]
+        [BsonElement(nameof(Payload))]
         public string Payload { get; set; }
 
-        [BsonElement("Metadata")]
         [BsonRequired]
+        [BsonElement("Metadata")]
         public EnvelopeHeaders Headers { get; set; }
 
         public static MongoEvent FromEventData(EventData data)
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEventCommit.cs b/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEventCommit.cs
index 10b3cea84..487c1b2e2 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEventCommit.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/EventSourcing/MongoEventCommit.cs
@@ -18,23 +18,23 @@ namespace Squidex.Infrastructure.EventSourcing
         public Guid Id { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Timestamp))]
         public BsonTimestamp Timestamp { get; set; }
 
-        [BsonElement]
         [BsonRequired]
+        [BsonElement(nameof(Events))]
         public MongoEvent[] Events { get; set; }
 
-        [BsonElement]
         [BsonRequired]
+        [BsonElement(nameof(EventStreamOffset))]
         public long EventStreamOffset { get; set; }
 
-        [BsonElement]
         [BsonRequired]
+        [BsonElement(nameof(EventsCount))]
         public long EventsCount { get; set; }
 
-        [BsonElement]
         [BsonRequired]
+        [BsonElement(nameof(EventStream))]
         public string EventStream { get; set; }
     }
 }
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/Log/MongoRequest.cs b/backend/src/Squidex.Infrastructure.MongoDb/Log/MongoRequest.cs
index fd51bc0ab..aa08e5a40 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/Log/MongoRequest.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/Log/MongoRequest.cs
@@ -14,19 +14,19 @@ namespace Squidex.Infrastructure.Log
     public sealed class MongoRequest
     {
         [BsonId]
-        [BsonElement]
+        [BsonElement("_id")]
         public ObjectId Id { get; set; }
 
-        [BsonElement]
         [BsonRequired]
+        [BsonElement(nameof(Key))]
         public string Key { get; set; }
 
-        [BsonElement]
         [BsonRequired]
+        [BsonElement(nameof(Timestamp))]
         public Instant Timestamp { get; set; }
 
-        [BsonElement]
         [BsonRequired]
+        [BsonElement(nameof(Properties))]
         public Dictionary<string, string> Properties { get; set; }
 
         public static MongoRequest FromRequest(Request request)
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/Migrations/MongoMigrationEntity.cs b/backend/src/Squidex.Infrastructure.MongoDb/Migrations/MongoMigrationEntity.cs
index ad6587beb..9ab456016 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/Migrations/MongoMigrationEntity.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/Migrations/MongoMigrationEntity.cs
@@ -13,12 +13,11 @@ namespace Squidex.Infrastructure.Migrations
     public sealed class MongoMigrationEntity
     {
         [BsonId]
-        [BsonElement]
-        [BsonRepresentation(BsonType.String)]
+        [BsonElement("_id")]
         public string Id { get; set; }
 
-        [BsonElement]
         [BsonRequired]
+        [BsonElement(nameof(IsLocked))]
         public bool IsLocked { get; set; }
 
         [BsonElement]
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/MongoDb/BsonJsonConvention.cs b/backend/src/Squidex.Infrastructure.MongoDb/MongoDb/BsonJsonConvention.cs
index 000aae341..35205a1c5 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/MongoDb/BsonJsonConvention.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/MongoDb/BsonJsonConvention.cs
@@ -15,6 +15,8 @@ namespace Squidex.Infrastructure.MongoDb
 {
     public static class BsonJsonConvention
     {
+        private static bool isRegistered;
+
         public static JsonSerializerOptions Options { get; set; } = new JsonSerializerOptions(JsonSerializerDefaults.Web);
 
         public static void Register(JsonSerializerOptions? options = null)
@@ -26,6 +28,11 @@ namespace Squidex.Infrastructure.MongoDb
                     Options = options;
                 }
 
+                if (isRegistered)
+                {
+                    return;
+                }
+
                 var pack = new ConventionPack();
 
                 pack.AddMemberMapConvention("JsonBson", memberMap =>
@@ -42,6 +49,8 @@ namespace Squidex.Infrastructure.MongoDb
                 });
 
                 ConventionRegistry.Register("json", pack, t => true);
+
+                isRegistered = true;
             }
             catch (BsonSerializationException)
             {
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/MongoDb/MongoBase.cs b/backend/src/Squidex.Infrastructure.MongoDb/MongoDb/MongoBase.cs
index c38e9ec38..912525612 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/MongoDb/MongoBase.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/MongoDb/MongoBase.cs
@@ -46,6 +46,7 @@ namespace Squidex.Infrastructure.MongoDb
 
         static MongoBase()
         {
+            BsonDefaultConventions.Register();
             BsonDomainIdSerializer.Register();
             BsonInstantSerializer.Register();
             BsonJsonConvention.Register();
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/States/MongoState.cs b/backend/src/Squidex.Infrastructure.MongoDb/States/MongoState.cs
index 90773b2ea..3bd5263eb 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/States/MongoState.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/States/MongoState.cs
@@ -11,12 +11,10 @@ using Squidex.Infrastructure.MongoDb;
 
 namespace Squidex.Infrastructure.States
 {
-    [BsonIgnoreExtraElements]
     public class MongoState<T> : IVersionedEntity<DomainId>
     {
         [BsonId]
-        [BsonElement]
-        [BsonRepresentation(BsonType.String)]
+        [BsonElement("_id")]
         public DomainId DocumentId { get; set; }
 
         [BsonRequired]
@@ -25,7 +23,7 @@ namespace Squidex.Infrastructure.States
         public T Document { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Version))]
         public long Version { get; set; }
 
         public virtual void Prepare()
diff --git a/backend/src/Squidex.Infrastructure.MongoDb/UsageTracking/MongoUsage.cs b/backend/src/Squidex.Infrastructure.MongoDb/UsageTracking/MongoUsage.cs
index d5e55a94c..528249925 100644
--- a/backend/src/Squidex.Infrastructure.MongoDb/UsageTracking/MongoUsage.cs
+++ b/backend/src/Squidex.Infrastructure.MongoDb/UsageTracking/MongoUsage.cs
@@ -13,25 +13,24 @@ namespace Squidex.Infrastructure.UsageTracking
     public sealed class MongoUsage
     {
         [BsonId]
-        [BsonElement]
-        [BsonRepresentation(BsonType.String)]
+        [BsonElement("_id")]
         public string Id { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Date))]
         [BsonDateTimeOptions(DateOnly = true)]
         public DateTime Date { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Key))]
         public string Key { get; set; }
 
         [BsonIgnoreIfNull]
-        [BsonElement]
+        [BsonElement(nameof(Category))]
         public string Category { get; set; }
 
         [BsonRequired]
-        [BsonElement]
+        [BsonElement(nameof(Counters))]
         public Counters Counters { get; set; } = new Counters();
     }
 }