diff --git a/apps/demo-api/src/app/function/guestbook/guestbookentry.function.spec.ts b/apps/demo-api/src/app/function/guestbook/guestbookentry.function.spec.ts
index 6f9cccc28..c4794fbf0 100644
--- a/apps/demo-api/src/app/function/guestbook/guestbookentry.function.spec.ts
+++ b/apps/demo-api/src/app/function/guestbook/guestbookentry.function.spec.ts
@@ -42,6 +42,29 @@ demoApiFunctionContextFactory((f: DemoApiFunctionContextFixture) => {
 
           describe('guestbook entry exists', () => {
             demoGuestbookEntryContext({ f, u, g }, (ge) => {
+              describe('reading a guestbook entry', () => {
+                describe('with incomplete database data', () => {
+                  beforeEach(async () => {
+                    // clear the data from the entry
+                    await ge.document.accessor.update({ updatedAt: null, createdAt: null } as any);
+                  });
+
+                  it('should read default times', async () => {
+                    const rawData = (await ge.document.accessor.getWithConverter(null)).data();
+
+                    expect(rawData?.updatedAt).toBeNull();
+                    expect(rawData?.createdAt).toBeNull();
+
+                    const data = await ge.document.snapshotData();
+
+                    expect(data?.updatedAt).toBeDefined();
+                    expect(data?.createdAt).toBeDefined();
+                    expect(isDate(data?.updatedAt)).toBe(true);
+                    expect(isDate(data?.createdAt)).toBe(true);
+                  });
+                });
+              });
+
               it('should update guestbook entry.', async () => {
                 const userGuestbookEntry = ge.document;
 
diff --git a/components/demo-firebase/src/lib/models/guestbook/guestbook.ts b/components/demo-firebase/src/lib/models/guestbook/guestbook.ts
index 278166b26..63c047687 100644
--- a/components/demo-firebase/src/lib/models/guestbook/guestbook.ts
+++ b/components/demo-firebase/src/lib/models/guestbook/guestbook.ts
@@ -54,13 +54,14 @@ export const guestbookConverter = snapshotConverterFunctions<Guestbook>({
 });
 
 export function guestbookCollectionReference(context: FirestoreContext): CollectionReference<Guestbook> {
-  return context.collection(guestbookIdentity.collection).withConverter<Guestbook>(guestbookConverter);
+  return context.collection(guestbookIdentity.collection);
 }
 
 export type GuestbookFirestoreCollection = FirestoreCollection<Guestbook, GuestbookDocument>;
 
 export function guestbookFirestoreCollection(firestoreContext: FirestoreContext): GuestbookFirestoreCollection {
   return firestoreContext.firestoreCollection({
+    converter: guestbookConverter,
     modelIdentity: guestbookIdentity,
     itemsPerPage: 50,
     collection: guestbookCollectionReference(firestoreContext),
@@ -116,7 +117,7 @@ export const guestbookEntryConverter = snapshotConverterFunctions<GuestbookEntry
 
 export function guestbookEntryCollectionReferenceFactory(context: FirestoreContext): (guestbook: GuestbookDocument) => CollectionReference<GuestbookEntry> {
   return (guestbook: GuestbookDocument) => {
-    return context.subcollection(guestbook.documentRef, guestbookEntryIdentity.collection).withConverter<GuestbookEntry>(guestbookEntryConverter);
+    return context.subcollection(guestbook.documentRef, guestbookEntryIdentity.collection);
   };
 }
 
@@ -130,6 +131,7 @@ export function guestbookEntryFirestoreCollectionFactory(firestoreContext: Fires
 
   return (parent: GuestbookDocument) => {
     return firestoreContext.firestoreCollectionWithParent({
+      converter: guestbookEntryConverter,
       modelIdentity: guestbookEntryIdentity,
       itemsPerPage: 50,
       collection: factory(parent),
@@ -142,13 +144,14 @@ export function guestbookEntryFirestoreCollectionFactory(firestoreContext: Fires
 }
 
 export function guestbookEntryCollectionReference(context: FirestoreContext): CollectionGroup<GuestbookEntry> {
-  return context.collectionGroup(guestbookEntryIdentity.collection).withConverter<GuestbookEntry>(guestbookEntryConverter);
+  return context.collectionGroup(guestbookEntryIdentity.collection);
 }
 
 export type GuestbookEntryFirestoreCollectionGroup = FirestoreCollectionGroup<GuestbookEntry, GuestbookEntryDocument>;
 
 export function guestbookEntryFirestoreCollectionGroup(firestoreContext: FirestoreContext): GuestbookEntryFirestoreCollectionGroup {
   return firestoreContext.firestoreCollectionGroup({
+    converter: guestbookEntryConverter,
     modelIdentity: guestbookEntryIdentity,
     itemsPerPage: 50,
     accessorFactory: guestbookEntryAccessorFactory,
diff --git a/components/demo-firebase/src/lib/models/profile/profile.ts b/components/demo-firebase/src/lib/models/profile/profile.ts
index 32145eaab..778dc1af9 100644
--- a/components/demo-firebase/src/lib/models/profile/profile.ts
+++ b/components/demo-firebase/src/lib/models/profile/profile.ts
@@ -48,7 +48,7 @@ export const profileConverter = snapshotConverterFunctions<Profile>({
 export const profileAccessorFactory = copyUserRelatedDataAccessorFactoryFunction<Profile>();
 
 export function profileCollectionReference(context: FirestoreContext): CollectionReference<Profile> {
-  return context.collection(profileIdentity.collection).withConverter<Profile>(profileConverter);
+  return context.collection(profileIdentity.collection);
 }
 
 export type ProfileFirestoreCollection = FirestoreCollection<Profile, ProfileDocument>;
@@ -56,6 +56,7 @@ export type ProfileFirestoreCollection = FirestoreCollection<Profile, ProfileDoc
 export function profileFirestoreCollection(firestoreContext: FirestoreContext): ProfileFirestoreCollection {
   return firestoreContext.firestoreCollection({
     modelIdentity: profileIdentity,
+    converter: profileConverter,
     itemsPerPage: 50,
     accessorFactory: profileAccessorFactory,
     collection: profileCollectionReference(firestoreContext),
@@ -97,7 +98,7 @@ export const profilePrivateDataConverter = snapshotConverterFunctions<ProfilePri
 
 export function profilePrivateDataCollectionReferenceFactory(context: FirestoreContext): (profile: ProfileDocument) => CollectionReference<ProfilePrivateData> {
   return (profile: ProfileDocument) => {
-    return context.subcollection(profile.documentRef, profilePrivateDataIdentity.collection).withConverter<ProfilePrivateData>(profilePrivateDataConverter);
+    return context.subcollection(profile.documentRef, profilePrivateDataIdentity.collection);
   };
 }
 
@@ -110,6 +111,7 @@ export function profilePrivateDataFirestoreCollectionFactory(firestoreContext: F
   return (parent: ProfileDocument) => {
     return firestoreContext.singleItemFirestoreCollection({
       modelIdentity: profilePrivateDataIdentity,
+      converter: profilePrivateDataConverter,
       itemsPerPage: 50,
       collection: factory(parent),
       makeDocument: (accessor, documentAccessor) => new ProfilePrivateDataDocument(accessor, documentAccessor),
@@ -121,7 +123,7 @@ export function profilePrivateDataFirestoreCollectionFactory(firestoreContext: F
 }
 
 export function profilePrivateDataCollectionReference(context: FirestoreContext): CollectionGroup<ProfilePrivateData> {
-  return context.collectionGroup(profilePrivateDataIdentity.collection).withConverter<ProfilePrivateData>(profilePrivateDataConverter);
+  return context.collectionGroup(profilePrivateDataIdentity.collection);
 }
 
 export type ProfilePrivateDataFirestoreCollectionGroup = FirestoreCollectionGroup<ProfilePrivateData, ProfilePrivateDataDocument>;
@@ -129,6 +131,7 @@ export type ProfilePrivateDataFirestoreCollectionGroup = FirestoreCollectionGrou
 export function profilePrivateDataFirestoreCollectionGroup(firestoreContext: FirestoreContext): ProfilePrivateDataFirestoreCollectionGroup {
   return firestoreContext.firestoreCollectionGroup({
     modelIdentity: profilePrivateDataIdentity,
+    converter: profilePrivateDataConverter,
     itemsPerPage: 50,
     queryLike: profilePrivateDataCollectionReference(firestoreContext),
     makeDocument: (accessor, documentAccessor) => new ProfilePrivateDataDocument(accessor, documentAccessor),
diff --git a/packages/firebase-server/src/lib/firestore/test.firestore.spec.ts b/packages/firebase-server/src/lib/firestore/test.firestore.spec.ts
index 0d6bf78a4..2d98c69d4 100644
--- a/packages/firebase-server/src/lib/firestore/test.firestore.spec.ts
+++ b/packages/firebase-server/src/lib/firestore/test.firestore.spec.ts
@@ -1,6 +1,6 @@
 import { DocumentReference, Transaction, Firestore } from '@google-cloud/firestore';
 import { DocumentSnapshot, makeFirestoreCollection } from '@dereekb/firebase';
-import { mockItemIdentity, MockItem, mockItemCollectionReference, MockItemDocument, MockItemFirestoreCollection } from '@dereekb/firebase/test';
+import { mockItemIdentity, MockItem, mockItemCollectionReference, MockItemDocument, MockItemFirestoreCollection, mockItemConverter } from '@dereekb/firebase/test';
 import { Maybe } from '@dereekb/util';
 import { adminTestWithMockItemCollection } from '@dereekb/firebase-server/test';
 import { googleCloudFirestoreDrivers } from './driver';
@@ -20,6 +20,7 @@ describe('FirestoreCollection', () => {
         const itemsPerPage = 50;
 
         firestoreCollection = makeFirestoreCollection({
+          converter: mockItemConverter,
           modelIdentity: mockItemIdentity,
           firestoreContext: f.parent.context,
           itemsPerPage,
diff --git a/packages/firebase/src/lib/client/firestore/test.firestore.spec.ts b/packages/firebase/src/lib/client/firestore/test.firestore.spec.ts
index 1a22fb811..ddc478eb2 100644
--- a/packages/firebase/src/lib/client/firestore/test.firestore.spec.ts
+++ b/packages/firebase/src/lib/client/firestore/test.firestore.spec.ts
@@ -1,5 +1,5 @@
 import { DocumentSnapshot, DocumentReference, runTransaction, Transaction, Firestore, writeBatch } from '@firebase/firestore';
-import { MockItem, mockItemCollectionReference, MockItemDocument, MockItemFirestoreCollection, mockItemFirestoreCollection, authorizedTestWithMockItemCollection, mockItemIdentity } from '@dereekb/firebase/test';
+import { MockItem, mockItemCollectionReference, MockItemDocument, MockItemFirestoreCollection, mockItemFirestoreCollection, authorizedTestWithMockItemCollection, mockItemIdentity, mockItemConverter } from '@dereekb/firebase/test';
 import { FirestoreDocumentContext, makeFirestoreCollection } from '../../common/firestore';
 import { transactionDocumentContext } from './driver.accessor.transaction';
 import { Maybe } from '@dereekb/util';
@@ -20,6 +20,7 @@ describe('FirestoreCollection', () => {
         const itemsPerPage = 50;
 
         firestoreCollection = makeFirestoreCollection({
+          converter: mockItemConverter,
           modelIdentity: mockItemIdentity,
           firestoreContext: f.parent.context,
           itemsPerPage,
diff --git a/packages/firebase/src/lib/common/firestore/accessor/accessor.wrap.ts b/packages/firebase/src/lib/common/firestore/accessor/accessor.wrap.ts
index 765c20078..50bc5a34c 100644
--- a/packages/firebase/src/lib/common/firestore/accessor/accessor.wrap.ts
+++ b/packages/firebase/src/lib/common/firestore/accessor/accessor.wrap.ts
@@ -45,7 +45,7 @@ export abstract class AbstractFirestoreDocumentDataAccessorWrapper<T, D = Docume
   }
 
   update(data: UpdateData<D>, params?: FirestoreDocumentUpdateParams): Promise<void | WriteResult> {
-    return this.update(data, params);
+    return this.accessor.update(data, params);
   }
 }
 
diff --git a/packages/firebase/src/lib/common/firestore/accessor/document.ts b/packages/firebase/src/lib/common/firestore/accessor/document.ts
index 1946ccfc3..bb980a358 100644
--- a/packages/firebase/src/lib/common/firestore/accessor/document.ts
+++ b/packages/firebase/src/lib/common/firestore/accessor/document.ts
@@ -6,7 +6,7 @@ import { FirestoreAccessorDriverRef } from '../driver/accessor';
 import { FirestoreModelId, FirestoreModelIdRef, FirestoreModelKey, FirestoreModelKeyRef, FirestoreModelName } from './../collection/collection';
 import { DocumentReference, CollectionReference, Transaction, WriteBatch, DocumentSnapshot, SnapshotOptions, WriteResult } from '../types';
 import { createOrUpdateWithAccessorSet, dataFromSnapshotStream, FirestoreDocumentDataAccessor } from './accessor';
-import { CollectionReferenceRef, DocumentReferenceRef, FirestoreContextReference } from '../reference';
+import { CollectionReferenceRef, DocumentReferenceRef, FirestoreContextReference, FirestoreDataConverterRef } from '../reference';
 import { FirestoreDocumentContext } from './context';
 import { build, cachedGetter, Maybe } from '@dereekb/util';
 import { FirestoreModelNameRef, FirestoreModelIdentity, FirestoreModelIdentityRef } from '../collection/collection';
@@ -155,7 +155,7 @@ export interface LimitedFirestoreDocumentAccessorFactory<T, D extends FirestoreD
 /**
  * FirestoreDocumentAccessor configuration.
  */
-export interface LimitedFirestoreDocumentAccessorFactoryConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends FirestoreModelIdentityRef, FirestoreContextReference, FirestoreAccessorDriverRef {
+export interface LimitedFirestoreDocumentAccessorFactoryConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends FirestoreDataConverterRef<T>, FirestoreModelIdentityRef, FirestoreContextReference, FirestoreAccessorDriverRef {
   /**
    * Optional InterceptAccessorFactoryFunction to intercept/return a modified accessor factory.
    */
@@ -164,7 +164,7 @@ export interface LimitedFirestoreDocumentAccessorFactoryConfig<T, D extends Fire
 }
 
 export function limitedFirestoreDocumentAccessorFactory<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(config: LimitedFirestoreDocumentAccessorFactoryConfig<T, D>): LimitedFirestoreDocumentAccessorFactoryFunction<T, D> {
-  const { firestoreContext, firestoreAccessorDriver, makeDocument, accessorFactory: interceptAccessorFactory, modelIdentity } = config;
+  const { firestoreContext, firestoreAccessorDriver, makeDocument, accessorFactory: interceptAccessorFactory, converter, modelIdentity } = config;
   const expectedCollectionName = firestoreAccessorDriver.fuzzedPathForPath ? firestoreAccessorDriver.fuzzedPathForPath(modelIdentity.collection) : modelIdentity.collection;
 
   return (context?: FirestoreDocumentContext<T>) => {
@@ -177,6 +177,7 @@ export function limitedFirestoreDocumentAccessorFactory<T, D extends FirestoreDo
       }
 
       const accessor = dataAccessorFactory.accessorFor(ref);
+
       return makeDocument(accessor, documentAccessor);
     }
 
@@ -187,7 +188,7 @@ export function limitedFirestoreDocumentAccessorFactory<T, D extends FirestoreDo
         throw new Error(`unexpected key/path "${fullPath}" for expected type "${modelIdentity.collection}"/"${modelIdentity.model}".`);
       }
 
-      return ref;
+      return ref.withConverter(converter);
     }
 
     function loadDocumentForKey(fullPath: FirestoreModelKey): D {
@@ -230,11 +231,11 @@ export interface FirestoreDocumentAccessorFactoryConfig<T, D extends FirestoreDo
 }
 
 export function firestoreDocumentAccessorFactory<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(config: FirestoreDocumentAccessorFactoryConfig<T, D>): FirestoreDocumentAccessorFactoryFunction<T, D> {
-  const { firestoreAccessorDriver, collection } = config;
+  const { firestoreAccessorDriver, collection, converter } = config;
   const limitedFirestoreDocumentAccessor = limitedFirestoreDocumentAccessorFactory(config);
 
-  function documentRefForId(path: string, ...pathSegments: string[]): DocumentReference<T> {
-    return firestoreAccessorDriver.doc(collection, path, ...pathSegments);
+  function documentRefForId(path: string): DocumentReference<T> {
+    return firestoreAccessorDriver.doc(collection, path).withConverter(converter);
   }
 
   return (context?: FirestoreDocumentContext<T>) => {
@@ -250,12 +251,12 @@ export function firestoreDocumentAccessorFactory<T, D extends FirestoreDocument<
 
         x.documentRefForId = documentRefForId;
 
-        x.loadDocumentForId = (path: string, ...pathSegments: string[]): D => {
+        x.loadDocumentForId = (path: string): D => {
           if (!path) {
             throw new Error('Path was not provided to loadDocumentForId(). Use newDocument() for generating an id.');
           }
 
-          return documentAccessor.loadDocument(documentRefForId(path, ...pathSegments));
+          return documentAccessor.loadDocument(documentRefForId(path));
         };
       }
     });
diff --git a/packages/firebase/src/lib/common/firestore/context.ts b/packages/firebase/src/lib/common/firestore/context.ts
index a08cbef72..5765dfe76 100644
--- a/packages/firebase/src/lib/common/firestore/context.ts
+++ b/packages/firebase/src/lib/common/firestore/context.ts
@@ -44,15 +44,20 @@ export type FirestoreContextFactory<F extends Firestore = Firestore> = (firestor
  */
 export function firestoreContextFactory<F extends Firestore = Firestore>(drivers: FirestoreDrivers): FirestoreContextFactory<F> {
   return (firestore: F) => {
-    const makeFirestoreCollectionConfig = <T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>>(config: FirestoreContextFirestoreCollectionConfig<T, D> | FirestoreContextFirestoreCollectionGroupConfig<T, D> | FirestoreContextFirestoreCollectionWithParentConfig<T, PT, D, PD> | FirestoreContextSingleItemFirestoreCollectionConfig<T, PT, D, PD>) => ({
-      ...config,
-      queryLike: (config as FirestoreContextFirestoreCollectionConfig<T, D>).collection ?? (config as FirestoreContextFirestoreCollectionGroupConfig<T, D>).queryLike,
-      firestoreContext: context,
-      driverIdentifier: drivers.driverIdentifier,
-      driverType: drivers.driverType,
-      firestoreQueryDriver: drivers.firestoreQueryDriver,
-      firestoreAccessorDriver: drivers.firestoreAccessorDriver
-    });
+    const makeFirestoreCollectionConfig = <T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>>(config: FirestoreContextFirestoreCollectionConfig<T, D> | FirestoreContextFirestoreCollectionGroupConfig<T, D> | FirestoreContextFirestoreCollectionWithParentConfig<T, PT, D, PD> | FirestoreContextSingleItemFirestoreCollectionConfig<T, PT, D, PD>) => {
+      const queryLike = (config as FirestoreContextFirestoreCollectionConfig<T, D>).collection ?? (config as FirestoreContextFirestoreCollectionGroupConfig<T, D>).queryLike;
+
+      return {
+        ...config,
+        collection: config.converter ? (config as FirestoreContextFirestoreCollectionConfig<T, D>).collection?.withConverter(config.converter) : (config as FirestoreContextFirestoreCollectionConfig<T, D>).collection,
+        queryLike: config.converter ? queryLike.withConverter(config.converter) : queryLike,
+        firestoreContext: context,
+        driverIdentifier: drivers.driverIdentifier,
+        driverType: drivers.driverType,
+        firestoreQueryDriver: drivers.firestoreQueryDriver,
+        firestoreAccessorDriver: drivers.firestoreAccessorDriver
+      };
+    };
 
     const firestoreCollection = <T, D extends FirestoreDocument<T>>(config: FirestoreContextFirestoreCollectionConfig<T, D>) => makeFirestoreCollection(makeFirestoreCollectionConfig(config) as FirestoreCollectionConfig<T, D>);
     const firestoreCollectionGroup = <T, D extends FirestoreDocument<T>>(config: FirestoreContextFirestoreCollectionGroupConfig<T, D>) => makeFirestoreCollectionGroup(makeFirestoreCollectionConfig(config));
diff --git a/packages/firebase/src/lib/common/firestore/reference.ts b/packages/firebase/src/lib/common/firestore/reference.ts
index 77874363c..e2568a8cf 100644
--- a/packages/firebase/src/lib/common/firestore/reference.ts
+++ b/packages/firebase/src/lib/common/firestore/reference.ts
@@ -1,5 +1,5 @@
 import { FirestoreContext } from './context';
-import { CollectionReference, DocumentReference, Firestore, Query, Transaction } from './types';
+import { CollectionReference, DocumentReference, Firestore, FirestoreDataConverter, Query, Transaction } from './types';
 
 /**
  * Contains a reference to a Query.
@@ -35,3 +35,10 @@ export interface FirestoreContextReference<F extends Firestore = Firestore> {
 export interface FirebaseTransactionContext {
   readonly transaction?: Transaction;
 }
+
+/**
+ * Contains contextual information about the current Transaction, if available.
+ */
+export interface FirestoreDataConverterRef<U = unknown> {
+  readonly converter: FirestoreDataConverter<U>;
+}
diff --git a/packages/firebase/test/src/lib/common/firestore.mock.item.ts b/packages/firebase/test/src/lib/common/firestore.mock.item.ts
index e76527427..aa9768f3c 100644
--- a/packages/firebase/test/src/lib/common/firestore.mock.item.ts
+++ b/packages/firebase/test/src/lib/common/firestore.mock.item.ts
@@ -85,13 +85,14 @@ export const mockItemConverter = snapshotConverterFunctions<MockItem, MockItemDa
  * @returns
  */
 export function mockItemCollectionReference(context: FirestoreContext): CollectionReference<MockItem> {
-  return context.collection(mockItemIdentity.collection).withConverter<MockItem>(mockItemConverter);
+  return context.collection(mockItemIdentity.collection);
 }
 
 export type MockItemFirestoreCollection = FirestoreCollection<MockItem, MockItemDocument>;
 
 export function mockItemFirestoreCollection(firestoreContext: FirestoreContext): MockItemFirestoreCollection {
   return firestoreContext.firestoreCollection({
+    converter: mockItemConverter,
     modelIdentity: mockItemIdentity,
     itemsPerPage: 50,
     collection: mockItemCollectionReference(firestoreContext),
@@ -148,7 +149,7 @@ export const mockItemPrivateConverter = snapshotConverterFunctions({
  */
 export function mockItemPrivateCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemDocument) => CollectionReference<MockItemPrivate> {
   return (parent: MockItemDocument) => {
-    return context.subcollection(parent.documentRef, mockItemPrivateIdentity.collection).withConverter<MockItemPrivate>(mockItemPrivateConverter);
+    return context.subcollection(parent.documentRef, mockItemPrivateIdentity.collection);
   };
 }
 
@@ -161,6 +162,7 @@ export function mockItemPrivateFirestoreCollection(firestoreContext: FirestoreCo
   return (parent: MockItemDocument) => {
     return firestoreContext.singleItemFirestoreCollection({
       modelIdentity: mockItemPrivateIdentity,
+      converter: mockItemPrivateConverter,
       itemsPerPage: 50,
       collection: factory(parent),
       makeDocument: (a, d) => new MockItemPrivateDocument(a, d),
@@ -172,7 +174,7 @@ export function mockItemPrivateFirestoreCollection(firestoreContext: FirestoreCo
 }
 
 export function mockItemPrivateCollectionReference(context: FirestoreContext): CollectionGroup<MockItemPrivate> {
-  return context.collectionGroup(mockItemPrivateIdentity.collection).withConverter<MockItemPrivate>(mockItemPrivateConverter);
+  return context.collectionGroup(mockItemPrivateIdentity.collection);
 }
 
 export type MockItemPrivateFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemPrivate, MockItemPrivateDocument>;
@@ -180,6 +182,7 @@ export type MockItemPrivateFirestoreCollectionGroup = FirestoreCollectionGroup<M
 export function mockItemPrivateFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemPrivateFirestoreCollectionGroup {
   return firestoreContext.firestoreCollectionGroup({
     modelIdentity: mockItemPrivateIdentity,
+    converter: mockItemPrivateConverter,
     itemsPerPage: 50,
     queryLike: mockItemPrivateCollectionReference(firestoreContext),
     makeDocument: (accessor, documentAccessor) => new MockItemPrivateDocument(accessor, documentAccessor),
@@ -234,7 +237,7 @@ export const mockItemUserConverter = snapshotConverterFunctions({
  */
 export function mockItemUserCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemDocument) => CollectionReference<MockItemUser> {
   return (parent: MockItemDocument) => {
-    return context.subcollection(parent.documentRef, mockItemUserCollectionName).withConverter<MockItemUser>(mockItemUserConverter);
+    return context.subcollection(parent.documentRef, mockItemUserCollectionName);
   };
 }
 
@@ -249,6 +252,7 @@ export function mockItemUserFirestoreCollection(firestoreContext: FirestoreConte
   return (parent: MockItemDocument) => {
     return firestoreContext.firestoreCollectionWithParent({
       modelIdentity: mockItemUserIdentity,
+      converter: mockItemUserConverter,
       itemsPerPage: 50,
       collection: factory(parent),
       accessorFactory: mockItemUserAccessorFactory,
@@ -260,7 +264,7 @@ export function mockItemUserFirestoreCollection(firestoreContext: FirestoreConte
 }
 
 export function mockItemUserCollectionReference(context: FirestoreContext): CollectionGroup<MockItemUser> {
-  return context.collectionGroup(mockItemUserCollectionName).withConverter<MockItemUser>(mockItemUserConverter);
+  return context.collectionGroup(mockItemUserCollectionName);
 }
 
 export type MockItemUserFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemUser, MockItemUserDocument>;
@@ -268,6 +272,7 @@ export type MockItemUserFirestoreCollectionGroup = FirestoreCollectionGroup<Mock
 export function mockItemUserFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemUserFirestoreCollectionGroup {
   return firestoreContext.firestoreCollectionGroup({
     modelIdentity: mockItemUserIdentity,
+    converter: mockItemUserConverter,
     itemsPerPage: 50,
     queryLike: mockItemUserCollectionReference(firestoreContext),
     accessorFactory: mockItemUserAccessorFactory,
@@ -312,7 +317,7 @@ export const mockItemSubItemConverter = snapshotConverterFunctions<MockItemSubIt
 
 export function mockItemSubItemCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemDocument) => CollectionReference<MockItemSubItem> {
   return (parent: MockItemDocument) => {
-    return context.subcollection(parent.documentRef, mockItemSubItemIdentity.collection).withConverter<MockItemSubItem>(mockItemSubItemConverter);
+    return context.subcollection(parent.documentRef, mockItemSubItemIdentity.collection);
   };
 }
 
@@ -325,6 +330,7 @@ export function mockItemSubItemFirestoreCollection(firestoreContext: FirestoreCo
   return (parent: MockItemDocument) => {
     return firestoreContext.firestoreCollectionWithParent({
       modelIdentity: mockItemSubItemIdentity,
+      converter: mockItemSubItemConverter,
       itemsPerPage: 50,
       collection: factory(parent),
       makeDocument: (a, d) => new MockItemSubItemDocument(a, d),
@@ -335,7 +341,7 @@ export function mockItemSubItemFirestoreCollection(firestoreContext: FirestoreCo
 }
 
 export function mockItemSubItemCollectionReference(context: FirestoreContext): CollectionGroup<MockItemSubItem> {
-  return context.collectionGroup(mockItemSubItemIdentity.collection).withConverter<MockItemSubItem>(mockItemSubItemConverter);
+  return context.collectionGroup(mockItemSubItemIdentity.collection);
 }
 
 export type MockItemSubItemFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemSubItem, MockItemSubItemDocument>;
@@ -343,6 +349,7 @@ export type MockItemSubItemFirestoreCollectionGroup = FirestoreCollectionGroup<M
 export function mockItemSubItemFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemSubItemFirestoreCollectionGroup {
   return firestoreContext.firestoreCollectionGroup({
     modelIdentity: mockItemSubItemIdentity,
+    converter: mockItemSubItemConverter,
     itemsPerPage: 50,
     queryLike: mockItemSubItemCollectionReference(firestoreContext),
     makeDocument: (accessor, documentAccessor) => new MockItemSubItemDocument(accessor, documentAccessor),
@@ -386,7 +393,7 @@ export const mockItemSubItemDeepConverter = snapshotConverterFunctions<MockItemS
 
 export function mockItemSubItemDeepCollectionReferenceFactory(context: FirestoreContext): (parent: MockItemSubItemDocument) => CollectionReference<MockItemSubItemDeep> {
   return (parent: MockItemSubItemDocument) => {
-    return context.subcollection(parent.documentRef, mockItemSubItemDeepIdentity.collection).withConverter<MockItemSubItemDeep>(mockItemSubItemDeepConverter);
+    return context.subcollection(parent.documentRef, mockItemSubItemDeepIdentity.collection);
   };
 }
 
@@ -399,6 +406,7 @@ export function mockItemSubItemDeepFirestoreCollection(firestoreContext: Firesto
   return (parent: MockItemSubItemDocument) => {
     return firestoreContext.firestoreCollectionWithParent({
       modelIdentity: mockItemSubItemDeepIdentity,
+      converter: mockItemSubItemDeepConverter,
       itemsPerPage: 50,
       collection: factory(parent),
       makeDocument: (a, d) => new MockItemSubItemDeepDocument(a, d),
@@ -409,7 +417,7 @@ export function mockItemSubItemDeepFirestoreCollection(firestoreContext: Firesto
 }
 
 export function mockItemSubItemDeepCollectionReference(context: FirestoreContext): CollectionGroup<MockItemSubItemDeep> {
-  return context.collectionGroup(mockItemSubItemDeepIdentity.collection).withConverter<MockItemSubItemDeep>(mockItemSubItemDeepConverter);
+  return context.collectionGroup(mockItemSubItemDeepIdentity.collection);
 }
 
 export type MockItemSubItemDeepFirestoreCollectionGroup = FirestoreCollectionGroup<MockItemSubItemDeep, MockItemSubItemDeepDocument>;
@@ -417,6 +425,7 @@ export type MockItemSubItemDeepFirestoreCollectionGroup = FirestoreCollectionGro
 export function mockItemSubItemDeepFirestoreCollectionGroup(firestoreContext: FirestoreContext): MockItemSubItemDeepFirestoreCollectionGroup {
   return firestoreContext.firestoreCollectionGroup({
     modelIdentity: mockItemSubItemDeepIdentity,
+    converter: mockItemSubItemDeepConverter,
     itemsPerPage: 50,
     queryLike: mockItemSubItemDeepCollectionReference(firestoreContext),
     makeDocument: (accessor, documentAccessor) => new MockItemSubItemDeepDocument(accessor, documentAccessor),
diff --git a/packages/firebase/test/src/lib/common/test.driver.accessor.ts b/packages/firebase/test/src/lib/common/test.driver.accessor.ts
index 69fe9f1d4..2e416cb99 100644
--- a/packages/firebase/test/src/lib/common/test.driver.accessor.ts
+++ b/packages/firebase/test/src/lib/common/test.driver.accessor.ts
@@ -99,12 +99,12 @@ export function describeAccessorDriverTests(f: MockItemCollectionFixture) {
           describe('get()', () => {
             it('should read that data using the configured converter', async () => {
               await itemPrivateDataDocument.accessor.set({ values: null } as any);
-              const dataWithoutConverter = (await itemPrivateDataDocument.accessor.getWithConverter(null)).data();
+              const dataWithoutConverter: any = (await itemPrivateDataDocument.accessor.getWithConverter(null)).data();
 
               expect(dataWithoutConverter).toBeDefined();
-              expect(dataWithoutConverter!.values).toBeNull();
+              expect(dataWithoutConverter.values).toBeNull();
 
-              expect(itemPrivateDataDocument.documentRef.converter).toBeDefined();
+              expect(itemPrivateDataDocument.documentRef.converter ?? (itemPrivateDataDocument.documentRef as any)._converter).toBeDefined();
 
               const data = await itemPrivateDataDocument.snapshotData();
               expect(data?.values).toBeDefined();
@@ -119,10 +119,10 @@ export function describeAccessorDriverTests(f: MockItemCollectionFixture) {
               const data = await itemPrivateDataDocument.snapshotData();
               expect(data?.values).toBeDefined();
 
-              const dataWithoutConverter = (await itemPrivateDataDocument.accessor.getWithConverter(null)).data();
+              const dataWithoutConverter: any = (await itemPrivateDataDocument.accessor.getWithConverter(null)).data();
 
               expect(dataWithoutConverter).toBeDefined();
-              expect(dataWithoutConverter!.values).toBeNull();
+              expect(dataWithoutConverter.values).toBeNull();
             });
 
             it('should get the results with the input converter with a type', async () => {
diff --git a/setup/templates/components/firebase/src/lib/models/example/example.ts b/setup/templates/components/firebase/src/lib/models/example/example.ts
index 121855cb8..124b08e32 100644
--- a/setup/templates/components/firebase/src/lib/models/example/example.ts
+++ b/setup/templates/components/firebase/src/lib/models/example/example.ts
@@ -32,7 +32,7 @@ export const exampleConverter = snapshotConverterFunctions<Example>({
 });
 
 export function exampleCollectionReference(context: FirestoreContext): CollectionReference<Example> {
-  return context.collection(exampleIdentity.collection).withConverter<Example>(exampleConverter);
+  return context.collection(exampleIdentity.collection);
 }
 
 export type ExampleFirestoreCollection = FirestoreCollection<Example, ExampleDocument>;
@@ -40,6 +40,7 @@ export type ExampleFirestoreCollection = FirestoreCollection<Example, ExampleDoc
 export function exampleFirestoreCollection(firestoreContext: FirestoreContext): ExampleFirestoreCollection {
   return firestoreContext.firestoreCollection({
     modelIdentity: exampleIdentity,
+    converter: exampleConverter,
     itemsPerPage: 50,
     collection: exampleCollectionReference(firestoreContext),
     makeDocument: (accessor, documentAccessor) => new ExampleDocument(accessor, documentAccessor),