↑ ↓ navigate↵ selectesc close

Firestore levels up: Bringing the power of search and JOINs to NoSQL in Firebase: Web Architecture & Implementation Guide

CodingCat.dev tutorial cover image
Alex Patterson
Alex Patterson

For years, choosing Firebase meant trading away relational SQL joins, strict foreign keys, and pgvector similarity search in favor of NoSQL document denormalization. Following the announcement of Firestore levels up: Bringing the power of search and JOINs to NoSQL by Morgan Chen, Minh Nguyen on the Official Firebase Blog (2026-04-27), here is our hands-on CodingCat.dev breakdown of what actually shipped, how it works under the hood, and how we wire it into production TypeScript, Next.js, Astro, SvelteKit, React, and Angular applications. In November Previously, the Firebase team announced pipeline operations on Firestore enterprise edition in public preview. This launch brought Firestore’s query configurability and capabilities closer to the capabilities of relational databases like PostgreSQL, while maximizing Firestore’s NoSQL data model, differentiated serverless architecture, built-in real-time sync and embedded offline querying. For example, this launch gave developers granular control over when to create an index to improve performance, as well as the ability to create complex multi-stage queries that weren’t possible in Firestore previously. At Next, pipeline operations graduated to general availability, and with it Firebase is adding several major heavily-requested queries: full text search, geospatial queries, JOIN capabilities via subqueries, and data manipulation.

The Mental Model: Why Firestore levels up: Bringing the power of search and JOINs to NoSQL Matters for Web Devs

As a Google Developer Expert (GDE) for Firebase and Senior Solutions Engineer at CodingCat.dev, I evaluate every Firebase update through one lens: does it reduce boilerplate while keeping our runtime security and cloud bills predictable? Firebase Data Connect bridges that gap by pairing a managed Google Cloud SQL for PostgreSQL instance with a declarative GraphQL schema compiler that automatically generates type-safe TypeScript, React, and Angular SDKs alongside server-enforced @auth directives.

AJ Pro-Tip from Alex: Keep your authorization logic inside your Data Connect GraphQL operations using @auth(level: USER) and server-evaluated expressions like auth.uid and request.time rather than trusting client-supplied user IDs in query variables.

How It Works: Technical Breakdown & Implementation

Full text search and geospatial queries (in public preview)

Firestore now provides built-in support for full-text search, which allows you to use familiar search query syntax like that of google.com to retrieve relevant Firestore documents. Unlike traditional queries, search queries use special text indexes that tokenize fields in your document. These indexes are then utilized to perform a relevancy search using Google’s best-in-class models, and a search relevance score is appended to the documents returned, allowing you to sort documents by relevance. As an example, suppose you’re the CTO of a company and you want an in-house database of vetted agent skills to provide to employees for security reasons. Your data model might look like this:

{
  "
    "
    "
    "
    "
  },
  "
  "
  "
}

You want your agent skills to be discoverable both via a human-browsable marketplace landing page as well as via another agent skill for finding and installing skills. You can combine Firestore’s search with other pipeline filters to produce a narrow list of results ranked by relevance:

const

  // Run the full text search. This must occur before other pipeline stages.
  .
    // Example query: "\"iOS\" docs generation"
    query: query,
    // Add the relevance score to the document for ranking later.
    addFields: [
      score
    ]
  })

  // Narrow results down to just what the user can use.
  .
  .

  // Order by relevance score.
  .
);

Firestore’s native full-text search provides a number of benefits over third-party search providers or even PostgreSQL’s native search solution. Furthermore, it allows you to run search queries in conjunction with other pipeline stages, automatically handling synonyms, spelling errors, and even difficult-to-handle search languages like traditional Chinese naturally without any plugins. It also uses a familiar search syntax that feels similar to google.com’s search syntax, meaning you don’t need to transform user input much before passing it to Firestore. In this case, combining the Firestore search stage with the two other where filters would allow you to both order by relevance based on the skills.md content and filter only skills compatible with your user’s local environment.

We’ve also added geospatial queries so that you can create location-aware applications. For example, you can query geographical coordinates by user proximity, sorting them by their distance to a specified location:

// Find restaurants with "waffles" on the menu, but order the results
// only by distance to a query point.
firestore.
  .
    query: 
    sort: 
      .
      .
  });

Since these are new major features, they’re available in preview while the rest of pipelines are GA.

Subqueries: Joins, but better

With Next’s GA release The Firebase team added a feature called subqueries, allowing you to write queries that combine two arbitrary pipelines into a single pipeline. This means that, for example, if you have a collection of restaurants and a subcollection of reviews:

// Restaurant
{
  "
  "
  // ...

  // Review (subcollection)
  {
    "
    "
    // ...
  }
}

You could write a query to aggregate each restaurant’s average rating into a single field per restaurant:

db.
  .
    subcollection
      .
	// Convert the subquery to a scalar value in the parent query.
      .
      .
  );

You can also use this feature to join documents from separate collections together within a pipeline by subquerying the collection you’d like to join and then passing it as a map into the document of the parent query’s collection, for example if you wanted to display a preview of a restaurant’s reviews under a restaurant thumbnail:

db.
  .
  .
    average
    count
  .
  .

The resulting document would look like this:

{
  "
  "
  "
    "
    "
  }
}

Data manipulation language (DML)

Have you ever written a Firestore pipeline query and decided you wanted to pipe the output of that query into some kind of update operation? Maybe you’re building a restaurant finder application and you want to add food categories to your app, requiring you to backfill a new field across every document that doesn’t already have it defined. Now you can do this directly within Firestore.

const
  .
  .
  .
  .
  .

DML is a set of pipeline stages that allow you to perform updates and deletes, so now you can make granular adjustments to your database fully within Firestore using the expressive pipeline operations to describe exactly which documents should be affected. Calling the update() function will merge the added field back into the document, persisting the value added by addFields(). Paired with the exists() check, this code conditionally adds fields only if they don’t exist. As this example shows, combining DML with other pipeline operations is an effective way to update entire collections of documents within Firestore without having to spin up a Cloud Function or other external service.

DML launched last week with updates and deletes, with inserts and transactions coming soon.

What’s next for Firestore?

After many years of waiting and many words on updates to the internals of Firestore, the queries you have been requesting from launch are now finally here for you to use. With these changes, we have achieved a major milestone in bringing Firestore to query feature parity with other major relational databases like PostgreSQL. Now, when you’re choosing a database for your new project, you no longer have to worry that Firestore’s queries won’t support an app feature you want to build.

Thanks for your patience, and we hope you continue to enjoy Firestore. As always, you can read more about search, DML, and subqueries as well as our getting started guide in the Firebase documentation.

Production Web Architecture & Security Checklist

Whether we are deploying on Firebase App Hosting, Cloudflare Workers, or Vercel, shipping AI features to production requires defense-in-depth across three layers:

  • Enforce Firebase App Check & Attestation: Protect your web endpoints, Cloud Functions, Data Connect GraphQL resolvers, and Firebase AI Logic calls against unauthorized replay or billing abuse using Firebase App Check with reCAPTCHA Enterprise.
  • Validate Locally with the Firebase Emulator Suite: Run deterministic integration tests against local Firestore, Auth, Functions, and Data Connect PostgreSQL emulators before promoting schema or rule changes to production.
  • Keep Server & Client Boundaries Type-Safe: Use the modular Firebase Web SDK and generated TypeScript bindings so SSR frameworks like Next.js, Astro, SvelteKit, and Angular serialize state cleanly without hydration flickers.

Conclusion

Accelerate your full-stack web and AI development by pairing Firestore levels up: Bringing the power of search and JOINs to NoSQL with strict Security Rules, Firebase App Check, and local emulator testing. Come tell us on X (@CodingCatDev) and LinkedIn (CodingCat.dev) how you are using Firebase in your stack, and subscribe to the CodingCat.dev YouTube Channel so you don't miss what we build next!

Watch Our Related Firebase Video Tutorial on YouTube

Want to see how we architect and debug Firebase web applications live? Watch our related CodingCat.dev session Firebase SQL with Data Connect below, and make sure to Subscribe to CodingCat.dev on YouTube for weekly full-stack web and AI deep dives:

Resources, Official Docs & Related CodingCat.dev Guides

Frequently Asked Questions (FAQ)

What are the key capabilities introduced in Firestore levels up: Bringing the power of search and JOINs to NoSQL?

Firestore levels up: Bringing the power of search and JOINs to NoSQL (announced 2026-04-27 by the Firebase team) enhances the platform for Firebase, Google Cloud, Web Dev, AI, SQL, Security, Serverless workloads. In November Previously, the Firebase team announced pipeline operations on Firestore enterprise edition in public preview. This launch brought Firestore’s query configurability and capabilities closer to the capabilities of relational databases like PostgreSQL, while maximizing Firestore’s NoSQL data model, differentiated serverless architecture, built-in real-time sync and embedded offline querying. For example, this launch gave developers granular control over when to create an index to improve performance, as well as the ability to create complex multi-stage queries that weren’t possible in Firestore previously. At Next, pipeline operations graduated to general availability, and with it Firebase is adding several major heavily-requested queries: full text search, geospatial queries, JOIN capabilities via subqueries, and data manipulation. Developers can review the primary announcement on the Firebase Blog alongside our implementation patterns and production checklist above.

How do web developers use Firestore levels up: Bringing the power of search and JOINs to NoSQL with Next.js, SvelteKit, React, or Angular?

Web developers can integrate these features using the modular Firebase JavaScript/TypeScript SDK, Firebase Data Connect web bindings, and Firebase App Hosting. Always pair client-side SDK initialization with Firebase App Check and strict Security Rules, and test locally with the Firebase Local Emulator Suite before deploying.

Where can I watch video tutorials on Firebase Web and AI development?

You can watch our hands-on Firebase video walkthroughs on the CodingCat.dev YouTube Channel, including Firebase SQL with Data Connect, and follow us on X (@CodingCatDev) for weekly full-stack tutorials.