Curriculum planned

Stage 03 · NoSQL, Search & Application Data

Firebase and Cloud Firestore

A complete Firebase/Cloud Firestore course covering Standard and Enterprise editions, Native Core and Pipeline operations, document modeling, SDKs, realtime listeners, offline persistence, queries and indexes, transactions, Security Rules, IAM/App Check, scaling and hotspots, aggregations, vector search, MongoDB compatibility, TTL, backups/PITR, encryption/networking, observability, cost engineering, migration, and production architecture.

Browse planned curriculum Back to all courses

27planned chapters

135reserved lesson paths

Beginner → Advancedlearning level

Plannedcourse state

Coverage baselineCurrent 2026 Firestore Standard and Enterprise capabilities, including Native Core/Pipeline operations, MongoDB compatibility, vector search, Query Explain/Insights, scheduled backups, and PITR

Course brief

Design client-facing document applications safely, then understand the serverless scaling, query, security, recovery, observability, and cost mechanics behind Firestore.

This syllabus deliberately separates foundations, modeling, querying, internals, reliability, security, performance, operations, and production design so advanced material is not compressed into generic catch-all chapters.

By the end

You will be able to

Model Firestore documents/collections/subcollections for access patterns, limits, atomicity, lifecycle, and scale
Use Core queries, indexes, listeners, offline persistence, transactions, batched writes, aggregations, and vector search correctly
Secure mobile/web access with Authentication, Security Rules and App Check while separating trusted server IAM paths
Understand Enterprise Native Pipeline operations and MongoDB compatibility without assuming identical behavior to Standard Native mode or MongoDB
Operate Firestore with backups/PITR, TTL, CMEK/network controls, Query Explain/Insights, quotas, cost models, testing, and production runbooks

Complete planned syllabus

27 chapters · 135 lesson paths.

Every lesson path is reserved now but intentionally not linked until its lesson HTML is actually published. The sequence moves from foundations through advanced implementation, architecture, operations, reliability, security, tuning, and a production capstone.

Chapter 1

Firestore Foundations, Firebase/Google Cloud, Editions, Modes, Locations, and Lab Setup

5 lessons

What Cloud Firestore Is: Serverless Document Database, Realtime Clients, Strong Consistency, and Workload FitPlanned lesson · reserved path Chapter01/Lesson1.html

Planned02

Standard vs Enterprise Editions and Native Core/Pipeline vs MongoDB Compatibility ModesPlanned lesson · reserved path Chapter01/Lesson2.html

Planned03

Firebase Projects, Google Cloud Projects, Databases, Regions/Multi-Regions, Billing, and Responsibility BoundariesPlanned lesson · reserved path Chapter01/Lesson3.html

Planned04

Create a Database, Configure SDKs/CLI, Use Emulator Suite Where Appropriate, and Verify Reads/WritesPlanned lesson · reserved path Chapter01/Lesson4.html

Planned05

Build a Reproducible Lab with Authentication, Rules, Test Data, Index Configuration, Logging, and Safe CleanupPlanned lesson · reserved path Chapter01/Lesson5.html

Planned

Chapter 2

Documents, Collections, Fields, References, Maps, Arrays, Timestamps, GeoPoints, and Limits

5 lessons

Document/Collection Hierarchy, Paths, IDs, Subcollections, and the Absence of Traditional Server-Side Joins in Core OperationsPlanned lesson · reserved path Chapter02/Lesson1.html

Planned02

Supported Native Data Types, Null, Numeric Ordering, Timestamps, References, GeoPoints, Bytes, Arrays, and MapsPlanned lesson · reserved path Chapter02/Lesson2.html

Planned03

Document Size, Field/Path/Nesting Constraints, Index Entry Implications, and Schema GovernancePlanned lesson · reserved path Chapter02/Lesson3.html

Planned04

Auto IDs vs Semantic IDs, Hotspot Risks, Tenant Prefixes, and External Identity MappingPlanned lesson · reserved path Chapter02/Lesson4.html

Planned05

Inspect and Validate a Document Schema Across Web/Mobile/Server SDK Serialization BoundariesPlanned lesson · reserved path Chapter02/Lesson5.html

Planned

Chapter 3

Data Modeling by Access Pattern: Embedding, Referencing, Duplication, Fan-Out, and Denormalization

5 lessons

Start from Screens/Queries/Transactions—not Entity Diagrams—When Designing Firestore ModelsPlanned lesson · reserved path Chapter03/Lesson1.html

Planned02

Embed vs Reference vs Duplicate: Read Cost, Write Amplification, Consistency, and Document LimitsPlanned lesson · reserved path Chapter03/Lesson2.html

Planned03

Subcollections vs Root Collections, Collection Groups, Ownership, Lifecycle, and Security RulesPlanned lesson · reserved path Chapter03/Lesson3.html

Planned04

Fan-Out Writes, Materialized Views, Counters, Feeds, and Precomputed Query ShapesPlanned lesson · reserved path Chapter03/Lesson4.html

Planned05

Refactor a Relational Model into Firestore and Document Every Consistency and Cost TradeoffPlanned lesson · reserved path Chapter03/Lesson5.html

Planned

Chapter 4

CRUD with Client and Server SDKs: Reads, Writes, Updates, Deletes, Preconditions, and Converters

5 lessons

Get Documents, Create/Set/Merge, Update, Delete, and Understand Missing vs Null FieldsPlanned lesson · reserved path Chapter04/Lesson1.html

Planned02

Field Paths, Nested Updates, Array Operations, Increment, Server Timestamps, and Atomic Field TransformsPlanned lesson · reserved path Chapter04/Lesson2.html

Planned03

Server vs Client SDK Authentication/Authorization Models and Trusted vs Untrusted ExecutionPlanned lesson · reserved path Chapter04/Lesson3.html

Planned04

Data Converters/Typed Models, Serialization, Validation, and Backward-Compatible Schema EvolutionPlanned lesson · reserved path Chapter04/Lesson4.html

Planned05

Build an Idempotent CRUD Service and Verify Error Handling, Retry, Preconditions, and ObservabilityPlanned lesson · reserved path Chapter04/Lesson5.html

Planned

Chapter 5

Queries: Filters, Ordering, Limits, Cursors, Collection Groups, and Query Constraints

5 lessons

Equality, Inequality, in/not-in, array-contains/array-contains-any, and Compound Query SemanticsPlanned lesson · reserved path Chapter05/Lesson1.html

Planned02

orderBy, limit/limitToLast, startAt/startAfter/endAt/endBefore, and Stable Cursor PaginationPlanned lesson · reserved path Chapter05/Lesson2.html

Planned03

Collection Group Queries Across Subcollections and Their Modeling/Security ImplicationsPlanned lesson · reserved path Chapter05/Lesson3.html

Planned04

Query Limitations, Field Existence Effects, Index Requirements, and How to Redesign Unsupported Access PatternsPlanned lesson · reserved path Chapter05/Lesson4.html

Planned05

Create a Query Contract Test Suite Covering Boundaries, Pagination, Empty Results, and Security ConstraintsPlanned lesson · reserved path Chapter05/Lesson5.html

Planned

Chapter 6

Indexes: Automatic/Composite/Collection-Group/Vector, Exemptions, and Index Cost

5 lessons

Single-Field Indexing in Standard Native Mode, Ascending/Descending/Array Entries, and Automatic BehaviorPlanned lesson · reserved path Chapter06/Lesson1.html

Planned02

Composite Indexes: Ordering, Equality/Range Fields, Collection vs Collection-Group Scope, and Error-Driven CreationPlanned lesson · reserved path Chapter06/Lesson2.html

Planned03

Index Exemptions for Large Strings/Arrays/Maps, Sequential Fields, TTL Fields, and Write/Storage CostPlanned lesson · reserved path Chapter06/Lesson3.html

Planned04

Enterprise Native Indexing Differences and Why Optional Indexing Changes Query-Performance ReasoningPlanned lesson · reserved path Chapter06/Lesson4.html

Planned05

Audit Index Usage, Remove Redundant Structures, and Validate Query Latency/Cost Before and After ChangesPlanned lesson · reserved path Chapter06/Lesson5.html

Planned

Chapter 7

Realtime Listeners: Snapshots, Change Events, Metadata, Latency, and Listener Lifecycle

5 lessons

Document vs Query Listeners, Initial Snapshot, Incremental Changes, Ordering, and Local WritesPlanned lesson · reserved path Chapter07/Lesson1.html

Planned02

Snapshot Metadata, Pending Writes, Cache vs Server Sources, and User-Experience SemanticsPlanned lesson · reserved path Chapter07/Lesson2.html

Planned03

Listener Fan-Out at Scale, Query Selectivity, Reconnects, Resume Behavior, and Bandwidth/Read CostPlanned lesson · reserved path Chapter07/Lesson3.html

Planned04

Unsubscribe/Lifecycle Management in Web/Mobile Frameworks and Avoiding Leaked ListenersPlanned lesson · reserved path Chapter07/Lesson4.html

Planned05

Design a Realtime Screen with Correct Offline/Online State, Security, Pagination, and Cost ControlsPlanned lesson · reserved path Chapter07/Lesson5.html

Planned

Chapter 8

Offline Persistence, Local Cache, Synchronization, Conflict Behavior, and Offline Indexes

5 lessons

Offline Cache Semantics for Android, Apple, and Web Clients: Reads, Writes, Listeners, and SynchronizationPlanned lesson · reserved path Chapter08/Lesson1.html

Planned02

Last-Write-Wins Behavior for Multiple Offline Changes and Where Transactions DifferPlanned lesson · reserved path Chapter08/Lesson2.html

Planned03

Memory vs Persistent Cache Options, Multi-Tab/Process Considerations, and Sensitive-Data RiskPlanned lesson · reserved path Chapter08/Lesson3.html

Planned04

Local Query Indexes, Cache Growth, User Sign-Out/Data Clearing, and Offline PerformancePlanned lesson · reserved path Chapter08/Lesson4.html

Planned05

Test Airplane-Mode, Restart, Conflicting Writes, Reconnect, and Security-Rule Changes End to EndPlanned lesson · reserved path Chapter08/Lesson5.html

Planned

Chapter 9

Transactions, Batched Writes, Atomic Field Operations, Retries, and Contention

5 lessons

Transactions Read-Then-Write Atomically, Optimistic/Pessimistic Differences by SDK/Edition Context, and Retry SemanticsPlanned lesson · reserved path Chapter09/Lesson1.html

Planned02

Batched Writes for Atomic Multi-Document Changes Without Reads and Operation LimitsPlanned lesson · reserved path Chapter09/Lesson2.html

Planned03

Increment, arrayUnion/arrayRemove, Server Timestamp, Compare/Precondition Patterns, and Conflict ReductionPlanned lesson · reserved path Chapter09/Lesson3.html

Planned04

Hot Documents, High-Contention Counters, Sharded/Distributed Counter Patterns, and IdempotencyPlanned lesson · reserved path Chapter09/Lesson4.html

Planned05

Load-Test a Contended Workflow and Redesign It to Meet Throughput Without Violating CorrectnessPlanned lesson · reserved path Chapter09/Lesson5.html

Planned

Chapter 10

Atomicity Across Business Workflows: Counters, Reservations, Idempotency, and Event-Driven Consistency

5 lessons

Define the True Atomic Boundary: One Document, Transaction Set, or Eventual Multi-Step WorkflowPlanned lesson · reserved path Chapter10/Lesson1.html

Planned02

Distributed/Sharded Counters, Read Aggregation, Write Distribution, and Accuracy/Latency TradeoffsPlanned lesson · reserved path Chapter10/Lesson2.html

Planned03

Reservation/Inventory Patterns, Conditional Writes, Expiration, Compensation, and Oversell PreventionPlanned lesson · reserved path Chapter10/Lesson3.html

Planned04

Idempotency Keys, Exactly-Once Illusions, Cloud Functions/Eventarc Retries, and DeduplicationPlanned lesson · reserved path Chapter10/Lesson4.html

Planned05

Design a Saga-Like Firestore Workflow with Recovery, Replay, Monitoring, and Manual Repair PathsPlanned lesson · reserved path Chapter10/Lesson5.html

Planned

Chapter 11

Subcollections, Collection Groups, Hierarchies, Deletion, and Data Lifecycle

5 lessons

Deep Hierarchies vs Flat Collections: Queryability, Security, Ownership, and Operational ComplexityPlanned lesson · reserved path Chapter11/Lesson1.html

Planned02

Collection Group Queries and Index/Rules Requirements Across Parent DocumentsPlanned lesson · reserved path Chapter11/Lesson2.html

Planned03

Deleting Documents Does Not Automatically Delete Subcollections: Recursive Delete and Orphan RiskPlanned lesson · reserved path Chapter11/Lesson3.html

Planned04

Archiving, Soft Delete, Legal Retention, Tenant Deletion, Export, and Lifecycle State MachinesPlanned lesson · reserved path Chapter11/Lesson4.html

Planned05

Implement a Tenant/Data-Subject Deletion Plan that Finds and Verifies All Hierarchical DataPlanned lesson · reserved path Chapter11/Lesson5.html

Planned

Chapter 12

Security Rules Foundations: Authentication Context, Match Paths, Reads/Writes, and Validation

5 lessons

Security Rules Execution Model, request/resource, Auth Context, and Rules Are Not FiltersPlanned lesson · reserved path Chapter12/Lesson1.html

Planned02

Path Matching, Wildcards, Recursive Wildcards, get/exists, and Access-Call LimitsPlanned lesson · reserved path Chapter12/Lesson2.html

Planned03

Separate create/update/delete/read/list/get Permissions and Validate Required/Immutable FieldsPlanned lesson · reserved path Chapter12/Lesson3.html

Planned04

Role/Ownership Models, Public/Private Documents, Nested Resources, and Deny-by-Default StructurePlanned lesson · reserved path Chapter12/Lesson4.html

Planned05

Write Emulator-Based Rules Tests for Allowed and Forbidden Cases Before Shipping Client QueriesPlanned lesson · reserved path Chapter12/Lesson5.html

Planned

Chapter 13

Advanced Security Rules, Query Compatibility, App Check, and Rules Testing

5 lessons

Secure Queries by Making Query Constraints Provably Compatible with RulesPlanned lesson · reserved path Chapter13/Lesson1.html

Planned02

Rules Functions, Reuse, Complexity, Access-Call Caching, and Avoiding Hidden Cost/Limit FailuresPlanned lesson · reserved path Chapter13/Lesson2.html

Planned03

App Check for Abuse Reduction: Attestation Concepts, Enforcement Boundaries, and Why It Is Not AuthorizationPlanned lesson · reserved path Chapter13/Lesson3.html

Planned04

Testing Rules in CI with Emulators, Fixtures, Authentication Claims, and Regression CasesPlanned lesson · reserved path Chapter13/Lesson4.html

Planned05

Threat-Model a Client App for ID Enumeration, Query Broadening, Forged Fields, Replay, and Rule DriftPlanned lesson · reserved path Chapter13/Lesson5.html

Planned

Chapter 14

IAM, Admin/Server SDKs, Service Accounts, Authentication, and Trust Boundaries

5 lessons

Firebase Authentication vs Google Cloud IAM vs Firestore Security Rules: Who Authorizes Which Request PathPlanned lesson · reserved path Chapter14/Lesson1.html

Planned02

Admin/Server SDKs Bypass Security Rules: Service Account Least Privilege and Application-Layer AuthorizationPlanned lesson · reserved path Chapter14/Lesson2.html

Planned03

Custom Claims, Tenant/Role Data, Token Refresh, Revocation, and Avoiding Authorization Only in UIPlanned lesson · reserved path Chapter14/Lesson3.html

Planned04

Workload Identity/Service Accounts, Keyless Credentials, Secrets, Rotation, and Local DevelopmentPlanned lesson · reserved path Chapter14/Lesson4.html

Planned05

Design Separate Browser/Mobile and Backend Access Paths with Explicit Trust, Audit, and Failure BoundariesPlanned lesson · reserved path Chapter14/Lesson5.html

Planned

Chapter 15

Scaling and Hotspots: Key Distribution, Index Fan-Out, Sequential Values, and Ramp-Up

5 lessons

Automatic Scaling Does Not Remove Hotspot Physics: Document, Key-Range, and Index ContentionPlanned lesson · reserved path Chapter15/Lesson1.html

Planned02

Sequential Document IDs/Timestamps, Monotonic Fields, High Write Rates, and Index HotspotsPlanned lesson · reserved path Chapter15/Lesson2.html

Planned03

The 500/50/5-Style Gradual Traffic Ramp Concept, New Collections, and Migration Warm-UpPlanned lesson · reserved path Chapter15/Lesson3.html

Planned04

Index Fan-Out, Large Arrays/Maps, High-Cardinality Fields, and Write Latency/CostPlanned lesson · reserved path Chapter15/Lesson4.html

Planned05

Load-Test a High-Write Model, Identify Hotspots, and Redesign Keys, Indexes, or Data DistributionPlanned lesson · reserved path Chapter15/Lesson5.html

Planned

Chapter 16

Aggregation Queries, Server-Side Count/Sum/Avg, Materialized Aggregates, and Analytics Boundaries

5 lessons

count(), sum(), avg() Semantics, Supported SDKs/Queries, and Index-Entry-Based CostPlanned lesson · reserved path Chapter16/Lesson1.html

Planned02

Aggregations with Filters/Collection Groups and Consistency ExpectationsPlanned lesson · reserved path Chapter16/Lesson2.html

Planned03

When to Maintain Write-Time Aggregates for Realtime Display vs Run Read-Time AggregationsPlanned lesson · reserved path Chapter16/Lesson3.html

Planned04

Large-Scale Analytics Limits and Exporting/Replicating Data to BigQuery or Analytical SystemsPlanned lesson · reserved path Chapter16/Lesson4.html

Planned05

Choose Between Query-Time Aggregation, Materialized Document, Distributed Counter, and External WarehousePlanned lesson · reserved path Chapter16/Lesson5.html

Planned

Chapter 17

Vector Search: Embeddings, KNN Indexes, Distance Measures, Filters, and Retrieval Design

5 lessons

Embedding Fundamentals, Model Versioning, Dimensions, Similarity/Distance, and Storing Vector ValuesPlanned lesson · reserved path Chapter17/Lesson1.html

Planned02

Create/Manage Firestore Vector Indexes and Understand Supported Dimensions/Query LimitsPlanned lesson · reserved path Chapter17/Lesson2.html

Planned03

K-Nearest-Neighbor Queries, Distance Thresholds, Metadata Filters, and Result RankingPlanned lesson · reserved path Chapter17/Lesson3.html

Planned04

Firestore Does Not Generate Embeddings: Vertex AI/External Generation Pipelines, Backfills, and UpdatesPlanned lesson · reserved path Chapter17/Lesson4.html

Planned05

Build and Evaluate a Semantic Retrieval Feature with Recall/Quality, Latency, Security, and Cost MeasurementsPlanned lesson · reserved path Chapter17/Lesson5.html

Planned

Chapter 18

Firestore Enterprise Native Mode: Core vs Pipeline Operations and Advanced Querying

5 lessons

Enterprise Edition Architecture/Query Engine and How Native Core Semantics Differ from StandardPlanned lesson · reserved path Chapter18/Lesson1.html

Planned02

Pipeline Operations: Pipeline Syntax Mental Model, Advanced Filters/Transforms/Aggregations, and Server SDK ContextPlanned lesson · reserved path Chapter18/Lesson2.html

Planned03

Relational-Style Join Capabilities Through Sub-Pipelines: Power, Cost, and Modeling ImplicationsPlanned lesson · reserved path Chapter18/Lesson3.html

Planned04

Index-Optional Querying in Enterprise: Query Explain, Performance, and When to Add IndexesPlanned lesson · reserved path Chapter18/Lesson4.html

Planned05

Translate an Access Pattern Between Standard Core Queries and Enterprise Pipeline Operations and Compare TradeoffsPlanned lesson · reserved path Chapter18/Lesson5.html

Planned

Chapter 19

Firestore with MongoDB Compatibility: Drivers, MQL/BSON, Tools, and Serverless Differences

5 lessons

Enterprise MongoDB Compatibility Mode, MongoDB Protocol/Drivers, Connection Strings, and AuthenticationPlanned lesson · reserved path Chapter19/Lesson1.html

Planned02

Supported BSON Types, _id Rules, Documents/Collections, MQL Query/CRUD Compatibility, and LimitsPlanned lesson · reserved path Chapter19/Lesson2.html

Planned03

mongosh, Compass, mongoimport/export, mongodump/restore, Mongoose, and Tool Compatibility BoundariesPlanned lesson · reserved path Chapter19/Lesson3.html

Planned04

Behavior Differences from MongoDB: Commands, Transactions/Features, Indexing, Change Semantics, and Operational ModelPlanned lesson · reserved path Chapter19/Lesson4.html

Planned05

Port a Small MongoDB Application and Build Compatibility Tests Instead of Assuming Drop-In EquivalencePlanned lesson · reserved path Chapter19/Lesson5.html

Planned

Chapter 20

Migrating MongoDB Workloads to Firestore MongoDB Compatibility

5 lessons

Inventory MongoDB Features, Drivers, Data Types, Indexes, Aggregations, Transactions, and Operational DependenciesPlanned lesson · reserved path Chapter20/Lesson1.html

Planned02

Compatibility Matrix Testing, Unsupported Features, Semantic Differences, and Application RefactoringPlanned lesson · reserved path Chapter20/Lesson2.html

Planned03

Bulk Migration with Export/Import or Datastream→Cloud Storage→Dataflow Patterns and Change CapturePlanned lesson · reserved path Chapter20/Lesson3.html

Planned04

Dual-Run/Cutover Planning, Validation, Lag Monitoring, Read/Write Freeze, and RollbackPlanned lesson · reserved path Chapter20/Lesson4.html

Planned05

Execute a Migration Rehearsal with Counts, Checksums/Samples, Query Regression, Performance, and Failure RecoveryPlanned lesson · reserved path Chapter20/Lesson5.html

Planned

Chapter 21

TTL, Retention, Expiration, Backfills, and Lifecycle Automation

5 lessons

TTL Policies and Expiration Fields: Asynchronous Deletion Semantics and Non-Instant GuaranteesPlanned lesson · reserved path Chapter21/Lesson1.html

Planned02

Index Exemptions for TTL Fields, Sequential Timestamp Costs, and Write Throughput ConsiderationsPlanned lesson · reserved path Chapter21/Lesson2.html

Planned03

Soft Delete vs TTL vs Scheduled/Batch Cleanup vs Archive: Compliance and Product RequirementsPlanned lesson · reserved path Chapter21/Lesson3.html

Planned04

Backfilling TTL Fields Safely, Monitoring Deletion, Event Side Effects, and CostPlanned lesson · reserved path Chapter21/Lesson4.html

Planned05

Design Retention for Sessions, Events, User Data, Audit Records, and Legal Holds Without Accidental LossPlanned lesson · reserved path Chapter21/Lesson5.html

Planned

Chapter 22

Backups, Point-in-Time Recovery, Restore, and Disaster Recovery

5 lessons

Scheduled Backups, Backup Retention, Database Restore/Clone Concepts, and Access ControlPlanned lesson · reserved path Chapter22/Lesson1.html

Planned02

PITR Window Semantics, Historical Reads/Recovery, and Accidental Write/Delete ScenariosPlanned lesson · reserved path Chapter22/Lesson2.html

Planned03

Export/Import vs Managed Backups/PITR: Different Purposes, RPO/RTO, and Operational WorkflowsPlanned lesson · reserved path Chapter22/Lesson3.html

Planned04

Multi-Region Location Does Not Replace Backup: Failure Modes, Logical Corruption, and Operator MistakesPlanned lesson · reserved path Chapter22/Lesson4.html

Planned05

Run a Recovery Drill and Measure Data Completeness, RPO, RTO, Rules/Indexes/Configuration, and Application CutoverPlanned lesson · reserved path Chapter22/Lesson5.html

Planned

Chapter 23

Encryption, CMEK, Network Access, Private Connectivity, and Data Governance

5 lessons

Encryption at Rest/In Transit, Google-Managed Keys, CMEK Concepts, Key Availability, Rotation, and Failure ImpactPlanned lesson · reserved path Chapter23/Lesson1.html

Planned02

VPC/Private Google Access and Service Perimeter Concepts Where Applicable, Egress Paths, and Trusted BackendsPlanned lesson · reserved path Chapter23/Lesson2.html

Planned03

Database Locations, Data Residency, Multi-Region Tradeoffs, Replication, and Governance RequirementsPlanned lesson · reserved path Chapter23/Lesson3.html

Planned04

PII Classification, Field-Level Design, Logging Redaction, Backups, Exports, and Right-to-Delete WorkflowsPlanned lesson · reserved path Chapter23/Lesson4.html

Planned05

Build a Security/Governance Control Matrix Mapping Threats and Compliance Requirements to Firestore/Google Cloud ControlsPlanned lesson · reserved path Chapter23/Lesson5.html

Planned

Chapter 24

Observability: Query Explain, Query Insights, Key Visualizer, Metrics, Logs, and Troubleshooting

5 lessons

Cloud Monitoring Metrics for Reads/Writes/Deletes, Latency, Errors, Quotas, Storage, and Listener BehaviorPlanned lesson · reserved path Chapter24/Lesson1.html

Planned02

Query Explain to Inspect Execution, Index Use, Scanned/Returned Work, and Optimization EvidencePlanned lesson · reserved path Chapter24/Lesson2.html

Planned03

Query Insights to Identify Expensive/Slow Query Patterns and Prioritize TuningPlanned lesson · reserved path Chapter24/Lesson3.html

Planned04

Key Visualizer/Hotspot Diagnostics Where Available, Application Tracing, Logs, and Correlation IDsPlanned lesson · reserved path Chapter24/Lesson4.html

Planned05

Build a Troubleshooting Runbook for Permission Errors, Missing Indexes, Hotspots, Latency, Quota, and Cost SpikesPlanned lesson · reserved path Chapter24/Lesson5.html

Planned

Chapter 25

Cost Engineering, Quotas, Limits, Billing, and Capacity/Usage Forecasting

5 lessons

Read/Write/Delete/Index/Storage/Network/Backup/PITR Billing Dimensions and Edition DifferencesPlanned lesson · reserved path Chapter25/Lesson1.html

Planned02

Listener and Query Read Amplification, Index Entry Reads, Aggregations, Retries, and Hidden Cost MultipliersPlanned lesson · reserved path Chapter25/Lesson2.html

Planned03

Free Tier/Quotas vs Production Limits, Rate Limits, Daily Budgets, Alerts, and Abuse ControlsPlanned lesson · reserved path Chapter25/Lesson3.html

Planned04

Model Cost per User/Feature/Event and Compare Denormalization, Fan-Out, Aggregation, and Retention AlternativesPlanned lesson · reserved path Chapter25/Lesson4.html

Planned05

Load-Test and Cost-Test a Feature Before Launch with Explicit Volume, Growth, and Worst-Case AssumptionsPlanned lesson · reserved path Chapter25/Lesson5.html

Planned

Chapter 26

Testing, Emulator Suite, CI/CD, Index/Rules Deployment, and Schema Migration

5 lessons

Emulator Suite for Firestore/Auth/Functions-Like Integration Testing and Known Differences from ProductionPlanned lesson · reserved path Chapter26/Lesson1.html

Planned02

Seed/Reset Test Data, Deterministic IDs/Clock Handling, and Parallel Test IsolationPlanned lesson · reserved path Chapter26/Lesson2.html

Planned03

Version Security Rules and Index Definitions, CI Validation, Staged Deployment, and RollbackPlanned lesson · reserved path Chapter26/Lesson3.html

Planned04

Backward-Compatible Document Migrations, Dual Readers/Writers, Backfills, and Feature FlagsPlanned lesson · reserved path Chapter26/Lesson4.html

Planned05

Create a Production Deployment Checklist Covering Rules, Indexes, Billing, Backups, Observability, and RollbackPlanned lesson · reserved path Chapter26/Lesson5.html

Planned

Chapter 27

Production Capstone: Design, Secure, Scale, Search, Recover, and Operate a Firestore Application

5 lessons

Define User Journeys, Data Model, Queries, Realtime/Offline Needs, Atomicity, Retention, Security, SLOs, and Cost BudgetPlanned lesson · reserved path Chapter27/Lesson1.html

Planned02

Implement Documents/Indexes/Queries/Listeners/Transactions, Typed SDK Access, Security Rules, and Trusted Backend PathsPlanned lesson · reserved path Chapter27/Lesson2.html

Planned03

Add Aggregation, Vector Retrieval, Enterprise Pipeline or MongoDB Compatibility Only Where Requirements Justify ThemPlanned lesson · reserved path Chapter27/Lesson3.html

Planned04

Load-Test Hotspots, Test Offline/Conflict Paths, Run Security Tests, Enable Backup/PITR, Monitor Queries, and Rehearse RecoveryPlanned lesson · reserved path Chapter27/Lesson4.html

Planned05

Present the Architecture with Measured Cost/Latency, Data-Governance Controls, Known Limits, and Criteria for Choosing Another DatabasePlanned lesson · reserved path Chapter27/Lesson5.html

Planned