diff --git a/internal/worker/store/fire_store.go b/internal/worker/store/fire_store.go
index d1266a4..98940de 100644
--- a/internal/worker/store/fire_store.go
+++ b/internal/worker/store/fire_store.go
@@ -23,7 +23,9 @@
 //
 // In this layout, there is a single top-level collection called Namespaces,
 // with documents for each development environment. Within each namespace, there
-// are two collections: CVEs for CVERecords, and Updates for UpdateRecords.
+// are some collections:
+// - CVEs for CVERecords
+// - CommitUpdates for CommitUpdateRecords
 type FireStore struct {
 	namespace string
 	client    *firestore.Client
@@ -57,10 +59,10 @@
 	}, nil
 }
 
-// CreateUpdateRecord implements Store.CreateUpdateRecord.
+// CreateCommitUpdateRecord implements Store.CreateCommitUpdateRecord.
 // On successful return, r.ID is set to the record's ID.
-func (fs *FireStore) CreateUpdateRecord(ctx context.Context, r *UpdateRecord) (err error) {
-	defer derrors.Wrap(&err, "CreateUpdateRecord()")
+func (fs *FireStore) CreateCommitUpdateRecord(ctx context.Context, r *CommitUpdateRecord) (err error) {
+	defer derrors.Wrap(&err, "CreateCommitUpdateRecord()")
 
 	docref := fs.nsDoc.Collection(updateCollection).NewDoc()
 	if _, err := docref.Create(ctx, r); err != nil {
@@ -70,9 +72,9 @@
 	return nil
 }
 
-// SetUpdateRecord implements Store.SetUpdateRecord.
-func (fs *FireStore) SetUpdateRecord(ctx context.Context, r *UpdateRecord) (err error) {
-	defer derrors.Wrap(&err, "SetUpdateRecord(%q)", r.ID)
+// SetCommitUpdateRecord implements Store.SetCommitUpdateRecord.
+func (fs *FireStore) SetCommitUpdateRecord(ctx context.Context, r *CommitUpdateRecord) (err error) {
+	defer derrors.Wrap(&err, "SetCommitUpdateRecord(%q)", r.ID)
 
 	if r.ID == "" {
 		return errors.New("missing ID")
@@ -81,9 +83,9 @@
 	return err
 }
 
-// ListUpdateRecords implements Store.ListUpdateRecords.
-func (fs *FireStore) ListUpdateRecords(ctx context.Context) ([]*UpdateRecord, error) {
-	var urs []*UpdateRecord
+// ListCommitUpdateRecords implements Store.ListCommitUpdateRecords.
+func (fs *FireStore) ListCommitUpdateRecords(ctx context.Context) ([]*CommitUpdateRecord, error) {
+	var urs []*CommitUpdateRecord
 	iter := fs.nsDoc.Collection(updateCollection).Documents(ctx)
 	for {
 		docsnap, err := iter.Next()
@@ -93,7 +95,7 @@
 		if err != nil {
 			return nil, err
 		}
-		var ur UpdateRecord
+		var ur CommitUpdateRecord
 		if err := docsnap.DataTo(&ur); err != nil {
 			return nil, err
 		}
diff --git a/internal/worker/store/mem_store.go b/internal/worker/store/mem_store.go
index be04fa0..62282f1 100644
--- a/internal/worker/store/mem_store.go
+++ b/internal/worker/store/mem_store.go
@@ -18,7 +18,7 @@
 type MemStore struct {
 	mu            sync.Mutex
 	cveRecords    map[string]*CVERecord
-	updateRecords map[string]*UpdateRecord
+	updateRecords map[string]*CommitUpdateRecord
 }
 
 // NewMemStore creates a new, empty MemStore.
@@ -31,7 +31,7 @@
 // Clear removes all data from the MemStore.
 func (ms *MemStore) Clear(context.Context) error {
 	ms.cveRecords = map[string]*CVERecord{}
-	ms.updateRecords = map[string]*UpdateRecord{}
+	ms.updateRecords = map[string]*CommitUpdateRecord{}
 	return nil
 }
 
@@ -40,20 +40,20 @@
 	return ms.cveRecords
 }
 
-// CreateUpdateRecord implements Store.CreateUpdateRecord.
-func (ms *MemStore) CreateUpdateRecord(ctx context.Context, r *UpdateRecord) error {
+// CreateCommitUpdateRecord implements Store.CreateCommitUpdateRecord.
+func (ms *MemStore) CreateCommitUpdateRecord(ctx context.Context, r *CommitUpdateRecord) error {
 	r.ID = fmt.Sprint(rand.Uint32())
 	if ms.updateRecords[r.ID] != nil {
 		panic("duplicate ID")
 	}
 	r.UpdatedAt = time.Now()
-	return ms.SetUpdateRecord(ctx, r)
+	return ms.SetCommitUpdateRecord(ctx, r)
 }
 
-// SetUpdateRecord implements Store.SetUpdateRecord.
-func (ms *MemStore) SetUpdateRecord(_ context.Context, r *UpdateRecord) error {
+// SetCommitUpdateRecord implements Store.SetCommitUpdateRecord.
+func (ms *MemStore) SetCommitUpdateRecord(_ context.Context, r *CommitUpdateRecord) error {
 	if r.ID == "" {
-		return errors.New("SetUpdateRecord: need ID")
+		return errors.New("SetCommitUpdateRecord: need ID")
 	}
 	c := *r
 	c.UpdatedAt = time.Now()
@@ -61,9 +61,9 @@
 	return nil
 }
 
-// ListUpdateRecords implements Store.ListUpdateRecords.
-func (ms *MemStore) ListUpdateRecords(context.Context) ([]*UpdateRecord, error) {
-	var urs []*UpdateRecord
+// ListCommitUpdateRecords implements Store.ListCommitUpdateRecords.
+func (ms *MemStore) ListCommitUpdateRecords(context.Context) ([]*CommitUpdateRecord, error) {
+	var urs []*CommitUpdateRecord
 	for _, ur := range ms.updateRecords {
 		urs = append(urs, ur)
 	}
diff --git a/internal/worker/store/store.go b/internal/worker/store/store.go
index 776643d..4ab8556 100644
--- a/internal/worker/store/store.go
+++ b/internal/worker/store/store.go
@@ -93,9 +93,9 @@
 	}
 }
 
-// An UpdateRecord describes a single update operation, which reconciles
+// A CommitUpdateRecord describes a single update operation, which reconciles
 // a commit in the CVE list repo with the DB state.
-type UpdateRecord struct {
+type CommitUpdateRecord struct {
 	// The ID of this record in the DB. Needed to modify the record.
 	ID string
 	// When the update started and completed. If EndedAt is zero,
@@ -120,18 +120,18 @@
 
 // A Store is a storage system for the CVE database.
 type Store interface {
-	// CreateUpdateRecord creates a new UpdateRecord. It should be called at the start
-	// of an update. On successful return, the UpdateRecord's ID field will be
+	// CreateCommitUpdateRecord creates a new CommitUpdateRecord. It should be called at the start
+	// of an update. On successful return, the CommitUpdateRecord's ID field will be
 	// set to a new, unique ID.
-	CreateUpdateRecord(context.Context, *UpdateRecord) error
+	CreateCommitUpdateRecord(context.Context, *CommitUpdateRecord) error
 
-	// SetUpdateRecord modifies the UpdateRecord. Use the same record passed to
-	// CreateUpdateRecord, because it will have the correct ID.
-	SetUpdateRecord(context.Context, *UpdateRecord) error
+	// SetCommitUpdateRecord modifies the CommitUpdateRecord. Use the same record passed to
+	// CreateCommitUpdateRecord, because it will have the correct ID.
+	SetCommitUpdateRecord(context.Context, *CommitUpdateRecord) error
 
-	// ListUpdateRecords returns all the UpdateRecords in the store, from most to
+	// ListCommitUpdateRecords returns all the CommitUpdateRecords in the store, from most to
 	// least recent.
-	ListUpdateRecords(context.Context) ([]*UpdateRecord, error)
+	ListCommitUpdateRecords(context.Context) ([]*CommitUpdateRecord, error)
 
 	// RunTransaction runs the function in a transaction.
 	RunTransaction(context.Context, func(context.Context, Transaction) error) error
diff --git a/internal/worker/store/store_test.go b/internal/worker/store/store_test.go
index 8bf93cd..cc1dfb6 100644
--- a/internal/worker/store/store_test.go
+++ b/internal/worker/store/store_test.go
@@ -34,31 +34,31 @@
 	ctx := context.Background()
 	start := time.Date(2021, time.September, 1, 0, 0, 0, 0, time.Local)
 
-	u1 := &UpdateRecord{
+	u1 := &CommitUpdateRecord{
 		StartedAt:  start,
 		CommitHash: "abc",
 		NumTotal:   100,
 	}
-	must(t, s.CreateUpdateRecord(ctx, u1))
+	must(t, s.CreateCommitUpdateRecord(ctx, u1))
 	u1.EndedAt = u1.StartedAt.Add(10 * time.Minute)
 	u1.NumAdded = 100
-	must(t, s.SetUpdateRecord(ctx, u1))
-	u2 := &UpdateRecord{
+	must(t, s.SetCommitUpdateRecord(ctx, u1))
+	u2 := &CommitUpdateRecord{
 		StartedAt:  start.Add(time.Hour),
 		CommitHash: "def",
 		NumTotal:   80,
 	}
-	must(t, s.CreateUpdateRecord(ctx, u2))
+	must(t, s.CreateCommitUpdateRecord(ctx, u2))
 	u2.EndedAt = u2.StartedAt.Add(8 * time.Minute)
 	u2.NumAdded = 40
 	u2.NumModified = 40
-	must(t, s.SetUpdateRecord(ctx, u2))
-	got, err := s.ListUpdateRecords(ctx)
+	must(t, s.SetCommitUpdateRecord(ctx, u2))
+	got, err := s.ListCommitUpdateRecords(ctx)
 	if err != nil {
 		t.Fatal(err)
 	}
-	want := []*UpdateRecord{u2, u1}
-	diff(t, want, got, cmpopts.IgnoreFields(UpdateRecord{}, "UpdatedAt"))
+	want := []*CommitUpdateRecord{u2, u1}
+	diff(t, want, got, cmpopts.IgnoreFields(CommitUpdateRecord{}, "UpdatedAt"))
 	for _, g := range got {
 		if g.UpdatedAt.IsZero() {
 			t.Error("zero UpdatedAt field")
diff --git a/internal/worker/update.go b/internal/worker/update.go
index 61f82e8..a89b9a8 100644
--- a/internal/worker/update.go
+++ b/internal/worker/update.go
@@ -59,13 +59,13 @@
 	if err != nil {
 		return err
 	}
-	// Create a new UpdateRecord to describe this run of doUpdate.
-	ur := &store.UpdateRecord{
+	// Create a new CommitUpdateRecord to describe this run of doUpdate.
+	ur := &store.CommitUpdateRecord{
 		StartedAt:  time.Now(),
 		CommitHash: commitHash.String(),
 		NumTotal:   len(files),
 	}
-	if err := st.CreateUpdateRecord(ctx, ur); err != nil {
+	if err := st.CreateCommitUpdateRecord(ctx, ur); err != nil {
 		return err
 	}
 
@@ -82,10 +82,10 @@
 		}
 		numAdds, numMods, err := updateBatch(ctx, files[i:j], st, repo, commitHash, needsIssue)
 
-		// Change the UpdateRecord in the Store to reflect the results of the transaction.
+		// Change the CommitUpdateRecord in the Store to reflect the results of the transaction.
 		if err != nil {
 			ur.Error = err.Error()
-			if err2 := st.SetUpdateRecord(ctx, ur); err2 != nil {
+			if err2 := st.SetCommitUpdateRecord(ctx, ur); err2 != nil {
 				return fmt.Errorf("update failed with %w, could not set update record: %v", err, err2)
 			}
 			return err
@@ -95,13 +95,13 @@
 		// RunTransaction, because that function may be executed multiple times.
 		ur.NumAdded += numAdds
 		ur.NumModified += numMods
-		if err := st.SetUpdateRecord(ctx, ur); err != nil {
+		if err := st.SetCommitUpdateRecord(ctx, ur); err != nil {
 			return err
 		}
 	} // end loop
 
 	ur.EndedAt = time.Now()
-	return st.SetUpdateRecord(ctx, ur)
+	return st.SetCommitUpdateRecord(ctx, ur)
 }
 
 func updateBatch(ctx context.Context, batch []repoFile, st store.Store, repo *git.Repository, commitHash plumbing.Hash, needsIssue triageFunc) (numAdds, numMods int, err error) {