なぜ私はFirestoreを使わないのか?実際の開発で直面した限界とシステム設計の落とし穴を徹底解説

Firestoreの限界や設計上の落とし穴を論理的に解説する技術記事のアイキャッチ画像 データベース

Firestoreは、素早く開発を始めたい場面では非常に魅力的な選択肢です。
サーバー運用の負担を抑えつつ、リアルタイム同期や柔軟なデータ保存を実現できるため、プロトタイプや小規模サービスでは強力に機能します。
実際、初期開発のスピードだけを見れば、多くのチームにとって有力な候補になるはずです。

しかし、実際の開発が進み、要件が複雑になり、利用者数やデータ量が増えてくると、当初は見えにくかった設計上の制約が次第に表面化してきます。
クエリ設計、集計処理、トランザクションの考え方、権限制御、コストの増え方。
これらは単なる実装上の癖ではなく、システム全体の構造に影響する論点です。
便利そうに見える抽象化の背後で、何が失われ、どこに無理が生じるのか。
その理解なしに採用すると、後から大きな手戻りを招きかねません。

本記事では、Firestoreを感覚的に批判するのではなく、実務で問題になりやすいポイントを設計の観点から整理します。
たとえば、次のような論点です。

  • なぜ複雑な検索や集計が難しくなりやすいのか
  • なぜデータ構造がアプリケーション都合に強く引っ張られるのか
  • なぜアクセス数の増加が、そのままコストと設計負債に直結しやすいのか
  • なぜRDBの常識を持ち込むと、判断を誤りやすいのか

Firestoreを使うべきでない、と単純に断言したいわけではありません。
重要なのは、何に向いていて、何に向いていないのかを、技術的前提から冷静に見極めることです。
もし現在Firestoreの採用を検討しているなら、あるいはすでに運用しながら違和感を抱えているなら、その違和感の正体を言語化する材料になるはずです。
便利さの先にある限界。
そこを曖昧にしないための整理です。

  1. Firestoreとは何か?採用前に理解すべき特徴とよくある誤解
    1. Firestoreが向いているユースケースと向いていないユースケース
    2. なぜ初期開発ではFirestoreが魅力的に見えるのか
  2. Firestoreを使わないと判断した理由の全体像
    1. リアルタイム同期の便利さと引き換えに増える設計上の制約
    2. NoSQLだから自由、という見方が危険な理由
  3. Firestoreのデータモデルが複雑化しやすい理由
    1. ドキュメント指向データベースで正規化の発想が通用しにくい背景
    2. 非正規化が前提になることで保守性が落ちる場面
    3. コレクション設計を誤ると後戻りが難しい理由
  4. 複雑な検索と集計でFirestoreが苦しくなる理由
    1. 複数条件検索で設計が不自然になりやすい原因
    2. 集計処理をアプリケーション側へ逃がすことの問題点
    3. インデックス依存の運用が開発速度を鈍らせる場面
  5. トランザクションと整合性の観点で見たFirestoreの限界
    1. RDBの感覚で整合性を考えると危険な理由
    2. 同時更新や部分失敗が業務ロジックを複雑にする仕組み
    3. イベント駆動で補う設計が破綻しやすいケース
  6. Firestoreはなぜコストが読みにくいのか
    1. 読み取り回数ベースの課金が設計に与える影響
    2. アクセス増加とともに見えにくいコストが膨らむ構造
    3. 小規模では安く見えても中規模以降で判断を誤る理由
  7. セキュリティルールと権限制御が難しくなる本当の理由
    1. アプリケーションロジックと認可ルールが分断される問題
    2. ルールの見通しが悪くなると何が起きるのか
    3. テストしにくい権限制御が品質に与える悪影響
  8. 実務でFirestoreを避けたほうがよいシステムの特徴
    1. 業務システムや基幹データ管理と相性が悪い理由
    2. 分析基盤やレポーティング要件で苦戦しやすい背景
    3. 将来的な機能追加を見据えると設計負債になりやすいケース
  9. Firestoreの代替として検討したいデータベース設計の選択肢
    1. RDBを選ぶべき条件とその判断基準
    2. 用途に応じてNoSQLを使い分けるという発想
    3. 技術選定で見るべきは機能ではなく将来の変更容易性
  10. なぜ私はFirestoreを使わないのかを設計視点で総括する

Firestoreとは何か?採用前に理解すべき特徴とよくある誤解

Firestoreの基本概念と特徴を整理したクラウドデータベースの説明図

Firestoreは、Google Cloud上で提供されているドキュメント指向のデータベースです。
データはテーブルではなく、コレクションとドキュメントという単位で管理されます。
この時点で、RDBに慣れている人ほど注意が必要です。
見た目には単純で柔軟に見えますが、その柔軟さは「何をどう保存してもよい」という意味ではありません。
むしろ、後からどのように読み出すかを先に考えなければ、設計が崩れやすい種類のデータベースです。

Firestoreの特徴としてよく挙げられるのは、リアルタイム同期、サーバーレスに近い運用性、高いスケーラビリティ、そしてモバイルやWebアプリとの親和性です。
たしかにこれらは強みです。
特に、チャット、通知、簡易なダッシュボード、ユーザーごとに独立したデータ管理のような用途では、比較的短時間で形にしやすいでしょう。
SDKも整っており、認証基盤や周辺サービスと組み合わせやすい点も魅力です。

ただし、ここで起きやすい誤解があります。
Firestoreは「自由なスキーマで何でも簡単に作れる万能なデータベース」ではありません。
正確には、「アクセスパターンが比較的はっきりしているアプリケーションでは強いが、複雑な検索、横断的な集計、厳密な整合性を多用するシステムでは設計難易度が急上昇しやすいデータベース」です。
この違いを理解せずに採用すると、初期の快適さの反動として、後半で苦しみます。

Firestoreを評価するときは、保存のしやすさよりも、読み方の制約、更新時の一貫性、将来的な運用コストを見るべきです。
データベース選定で本当に重要なのは、書き始めるまでの速さではなく、仕様変更が重なったときに破綻しないことだからです。
ここを見誤ると、技術選定が短期最適化になってしまいます。

Firestoreが向いているユースケースと向いていないユースケース

Firestoreが向いているのは、データ構造が比較的単純で、1件ごとの読み書きが中心になり、リアルタイム更新の恩恵が大きいケースです。
たとえば、チャットアプリ、個人向けタスク管理、ユーザー単位で閉じた設定情報、軽量なフィード表示などです。
これらは、複雑な結合や大量集計をあまり必要とせず、クライアントから自然に扱いやすい形へデータを置けるため、Firestoreの思想と整合します。

一方で、向いていないのは、業務システム、複雑な検索条件を持つサービス、集計レポートが重要な管理画面、厳密な整合性が求められる注文処理や在庫管理のような領域です。
なぜか。
Firestoreでは、RDBのように柔軟な結合や集計をその場で自然に実行する発想が通用しにくいからです。
必要な表示や検索条件に合わせて、あらかじめデータを複製し、読みやすい形へ寄せておく必要が出てきます。
これは高速化のための工夫であると同時に、保守性を削る要因でもあります。

整理すると、判断軸は次のようになります。

観点 向いているケース 向いていないケース
データ構造 単純で独立性が高い 関連が多く複雑
検索要件 単純な条件検索中心 多条件検索や集計が多い
整合性要件 多少の分散を許容できる 厳密な一貫性が重要
開発目的 迅速な立ち上げ 長期運用の安定性重視

この表から分かるのは、Firestoreの採用可否は、技術の優劣ではなく要件との相性で決まるということです。
流行っているから使う、Firebaseと一緒で便利そうだから使う。
その判断は危ういと言わざるを得ません。
技術選定に必要なのは印象ではなく、要件と制約の対応関係です。

なぜ初期開発ではFirestoreが魅力的に見えるのか

初期開発でFirestoreが魅力的に見える理由は明確です。
まず、サーバーサイドの実装をかなり省略できます。
認証、データ保存、クライアントSDK、リアルタイム更新といった機能が一通り揃っているため、少人数でも短期間で動くものを作りやすいのです。
特にスタートアップや新規事業では、この立ち上がりの速さは非常に大きな価値を持ちます。

さらに、JSONに近い感覚でデータを扱えるため、RDBのテーブル設計やマイグレーション運用に不慣れなチームでも着手しやすいという側面があります。
画面に必要な構造へ寄せてデータを保存し、そのまま読み出す。
この体験は快適です。
小さな成功体験を得やすい設計でもあります。

しかし、ここに落とし穴があります。
初期開発で見えているのは、主に「書ける」「表示できる」「同期できる」という局所的な成功です。
まだ複雑な権限制御もない。
まだ検索条件も少ない。
まだデータ量も小さい。
まだ分析要件も固まっていない。
この「まだ」が積み重なっている段階では、多くの制約が問題として顕在化しません。
つまり、Firestoreが優れているというより、システムがまだ複雑ではないだけ、という場合が少なくないのです。

本当に問うべきなのは、半年後や一年後にも同じ設計で耐えられるかどうかです。
ユーザー数が増え、検索要件が増え、権限制御が細かくなり、管理画面や集計処理が必要になったとき、それでも自然に拡張できるか。
ここを考えずに初期の開発速度だけで選ぶと、後からアーキテクチャ全体の再検討が必要になります。
速く作れることと、長く持つことは別問題。
その切り分けが重要です。

Firestoreを使わないと判断した理由の全体像

Firestore非採用の判断材料を整理した設計検討のイメージ

Firestoreを使わないという判断は、単に好みの問題ではありません。
むしろ、システム設計の責任をどこに置くかという、かなり本質的な論点です。
Firestoreは確かに便利です。
少ない実装でデータ保存と同期を実現でき、初期開発の速度も出しやすい。
ですが、実務で扱うシステムは、動けば終わりではありません。
要件は増え、画面は増え、権限は細かくなり、検索条件や集計処理も増えていきます。
その過程で重要になるのは、局所的な実装のしやすさではなく、設計全体がどれだけ無理なく拡張できるかです。

私がFirestoreを避ける最大の理由は、初期の快適さと引き換えに、中長期で設計の自由度を失いやすいからです。
しかも、その不自由さは導入直後には見えにくい。
小さく始めた段階では、データは少なく、アクセスパターンも単純で、権限も粗いことが多いためです。
しかし、アプリケーションが成長すると、当初は便利だった抽象化が、逆に設計の制約として効いてきます。
ここが重要です。
Firestoreは「設計を不要にする道具」ではなく、「別種の設計責任を前倒しで要求する道具」なのです。

とくに問題になるのは、データ構造、読み取りコスト、整合性、検索要件、権限制御の五つです。
RDBであれば、正規化や結合、集計、トランザクションを組み合わせて比較的自然に吸収できる問題が、Firestoreでは事前のデータ配置やアプリケーションロジックの工夫に強く依存します。
その結果、仕様変更に弱い構造になりやすい。
これは開発現場では深刻です。
小さな要件変更が、複数ドキュメントの再設計や書き込みフローの見直しに波及するからです。

つまり、Firestoreを使わないという判断は、機能不足を責めているのではなく、システムの変化に対する耐性を重視した結果です。
短期最適か、長期最適か。
設計判断の分岐点です。

リアルタイム同期の便利さと引き換えに増える設計上の制約

Firestoreの大きな魅力の一つが、リアルタイム同期です。
クライアントがデータ変更を即座に受け取れるため、チャットや通知、共同編集に近い体験を比較的容易に実装できます。
この強みは確かです。
問題は、その便利さを前提に設計を進めたとき、システム全体の責務分離が曖昧になりやすい点にあります。

リアルタイム同期が強力だと、つい「クライアントが直接データを監視すればよい」という発想に寄りがちです。
すると、画面表示に必要な構造へデータを強く最適化したくなります。
これは初期段階では効率的です。
しかし、画面ごとに都合のよいデータ配置を進めると、同じ意味のデータを複数箇所に持つ非正規化が増え、更新責務が分散します。
結果として、一つの情報を変更するだけで複数ドキュメントの整合を取る必要が生じます。
便利さの代償です。

さらに、リアルタイムで監視する設計は、読み取り回数や接続数の増加とも結びつきます。
開発中は快適でも、ユーザー数や監視対象が増えると、構造そのものがコストへ跳ね返りやすい。
ここで初めて、同期モデルが単なるUI上の利点ではなく、課金やデータ設計とも不可分であることに気づきます。
つまり、リアルタイム同期は機能というより、アーキテクチャ上の前提条件なのです。

加えて、リアルタイム性が本当に必要な画面は、実はそれほど多くありません。
数秒遅れても問題ない管理画面や、明示的な再取得で十分な一覧画面まで、すべて同期前提で組むべきか。
ここを冷静に切り分けないと、必要以上に複雑な構造を抱え込むことになります。
便利だから使うのではなく、必要だから使う。
その順序が重要です。

NoSQLだから自由、という見方が危険な理由

Firestoreを含むNoSQL系データベースについて、「スキーマが柔軟だから自由度が高い」という説明をよく見かけます。
この説明は半分だけ正しい。
保存形式の厳密さが低いという意味では自由です。
しかし、システム設計全体として見たとき、その自由さはしばしば別の不自由さを生みます。
なぜなら、データの一貫性や再利用性、検索可能性を支える仕組みを、開発者自身が背負う割合が増えるからです。

RDBでは、テーブル設計、制約、結合、正規化といった考え方が、ある種の秩序を強制します。
これは面倒でもありますが、同時に複雑化を抑える仕組みでもあります。
一方、Firestoreでは、画面都合でネストした構造を簡単に持てますし、必要なら同じ情報を複数箇所に複製することもできます。
短期的には非常に扱いやすい。
しかし、自由に作れることと、うまく保守できることは別問題です。

危険なのは、柔軟性を設計の省略と取り違えることです。
たとえば、データの関係性を明示せずに実装を進めると、後から「どこを正として更新すべきか」が曖昧になります。
あるいは、将来必要になる検索条件を見越さずに保存すると、データはあるのに取り出しにくい状態になります。
これは自由の問題ではなく、モデル化の失敗です。

NoSQLでは、スキーマレスという言葉がしばしば誤解を招きます。
実際には、スキーマが不要なのではありません。
データベースが強制しないだけで、アプリケーションの内部には明確なスキーマと不変条件が必要です。
それを曖昧にしたまま開発すると、実装が進むほど暗黙の前提が増え、変更コストが高騰します。
自由に見えるが、実際には規律を強く要求する世界。
その認識がないまま採用するのは危険です。

Firestoreを使うかどうかを考える際には、「柔軟そうか」ではなく、「この自由を管理できる設計能力と運用体制があるか」を問うべきです。
技術の抽象化は、責任を消すのではなく、見えにくくするだけです。
そこを見抜けるかどうか。
採用判断の分水嶺です。

Firestoreのデータモデルが複雑化しやすい理由

Firestoreのドキュメント構造が複雑化していく様子を示す概念図

Firestoreの設計が難しくなる本質は、データをどう保存するかではなく、どのように読ませるかを先に固定しやすい点にあります。
RDBであれば、ある程度正規化しておき、必要に応じて結合や集計で見せ方を変えるという発想が取れます。
しかしFirestoreでは、複数のドキュメントを横断して柔軟に処理するよりも、最初から表示や取得に都合のよい形へデータを寄せておく設計が好まれます。
これは一見合理的です。
ところが、要件が増えるほど、その合理性が別方向から制約として効いてきます。

特に厄介なのは、データ同士の関係が増えてきたときです。
ユーザー、投稿、コメント、いいね、通知、権限、集計値。
このような複数概念が絡み始めると、単純なドキュメント保存では済まなくなります。
ある画面では投稿にユーザー名が埋め込まれていたほうが便利で、別の画面ではユーザーごとの投稿一覧を即座に引きたい。
そのたびに、どこに何を複製し、どの更新を誰が責任を持って反映するのかを考える必要が出てきます。
柔軟そうに見えて、実際にはかなり綿密なモデリングが求められる領域です。

Firestoreはスキーマを強制しないぶん、設計の失敗が実装後まで見えにくいという問題もあります。
RDBのように外部キーや制約違反で止めてもらえないため、アプリケーション側の都合で成立している暗黙の前提が増えがちです。
その結果、最初は簡潔だった構造が、運用の途中で少しずつ複雑なつぎはぎになっていきます。
データモデルの複雑化とは、機能の増加そのものではなく、整合した説明ができない構造が増えることです。
ここが重要です。

ドキュメント指向データベースで正規化の発想が通用しにくい背景

RDBの正規化は、重複を減らし、整合性を維持し、更新の一貫性を高めるための有効な手法です。
理論的にも実務的にも成熟しています。
ところが、Firestoreのようなドキュメント指向データベースでは、この発想をそのまま持ち込むと、期待した効果が得られないことがあります。
理由は単純で、データの取得単位と操作単位が、テーブルや行ではなく、ドキュメントとその周辺構造に寄っているからです。

たとえば、RDBならユーザー情報をusersテーブルに一元化し、投稿テーブルから外部キーで参照するのが自然です。
しかしFirestoreで同じ思想を徹底すると、投稿一覧を表示するたびに、投稿ドキュメントとは別にユーザー情報も参照しなければならず、読み取り回数や実装の複雑さが増えます。
そのため、投稿ドキュメントに投稿時点のユーザー名やアイコンURLを持たせるような設計が現実的な選択肢になります。
ここで正規化の原則は後退します。

つまり、Firestoreでは正規化が理論的に間違っているのではなく、運用上のコストとアクセスパターンの都合で採用しにくいのです。
言い換えると、データの整合性よりも、取得効率や表示効率が優先されやすい構造です。
この優先順位の違いを理解していないと、「きれいに分けたはずなのに使いにくい」という状態に陥ります。
設計原則そのものが変わるわけではありませんが、優先される最適化の軸が違う。
そこを見誤ると、RDBの常識がむしろ足かせになります。

非正規化が前提になることで保守性が落ちる場面

Firestoreで実用的な性能や扱いやすさを確保しようとすると、非正規化はほぼ避けられません。
同じ情報を複数のドキュメントに持たせ、画面ごとに読みやすい形へ配置する。
この方針自体は、ドキュメント指向では珍しくありません。
問題は、その複製が増えたときです。
複製された情報は、保存時点では便利でも、変更時には負債へ変わります。

分かりやすい例が、ユーザー名やプロフィール画像です。
投稿一覧、コメント一覧、通知一覧、それぞれに表示用のユーザー情報を埋め込めば、表示は速くなります。
しかし、ユーザーが名前を変更したとき、どこまで更新するのか。
過去投稿まで一括反映するのか。
履歴として残すのか。
画面によって表示が食い違ってもよいのか。
このような仕様判断が、データ複製の数だけ増えていきます。
単なる更新処理ではなく、意味論の問題です。

さらに厄介なのは、非正規化された構造では不整合が一時的にでも発生しやすい点です。
一部の書き込みが失敗した場合、ある画面では新しい値、別の画面では古い値が見えることがあります。
ユーザーから見ると、これはバグです。
しかし内部的には、非正規化と分散更新の帰結です。
つまり、保守性の低下とはコード量の増加だけではなく、仕様説明の難しさや障害時の追跡困難さも含みます。
データの重複は、単なるコピーではなく責務の複製でもある。
その認識が必要です。

コレクション設計を誤ると後戻りが難しい理由

Firestoreでは、コレクションとドキュメントの階層設計が、後のクエリ構造や権限制御、運用のしやすさに直結します。
ここで厄介なのは、最初の設計判断が後から広範囲に波及しやすいことです。
RDBなら、ある程度はビューやクエリ、インデックス追加で吸収できる変更もありますが、Firestoreではデータ配置そのものが読み取り方法と結びついているため、構造変更の影響が大きくなりがちです。

たとえば、コメントを投稿ドキュメント配下のサブコレクションに置くのか、独立したトップレベルコレクションに置くのか。
この判断は単なる見た目の違いではありません。
投稿単位で取得しやすいか、ユーザー単位で横断検索しやすいか、管理画面で集約しやすいか、セキュリティルールを書きやすいか、といった複数の論点に関わります。
最初は自然に見えた構造が、別の要件追加によって急に不都合になる。
よくある話です。

しかも、後から移行しようとすると、保存済みデータの再配置、クライアントコードの変更、権限ルールの書き換え、バッチ移行の設計など、多方面に作業が発生します。
単なるリファクタリングではありません。
データ移行を伴うアーキテクチャ変更です。
ここにFirestore設計の難しさがあります。
小さなアプリでは気にならなくても、運用データが増えた後では手を入れにくい。
だからこそ、コレクション設計は「今書きやすいか」ではなく、「将来どの方向へ要件が伸びても破綻しにくいか」で考える必要があります。
初手の設計。
軽く見てはいけない部分です。

複雑な検索と集計でFirestoreが苦しくなる理由

検索条件と集計要件が増えてFirestoreが苦しくなる分析イメージ

Firestoreが快適に使えるかどうかは、保存できるかではなく、必要な形で取り出せるかに大きく依存します。
この点で、複雑な検索や集計が要件に入ってくると、Firestoreは急に扱いづらくなります。
理由は単純ではありません。
クエリ機能そのものの制約、インデックス前提の設計、非正規化との組み合わせ、そして集計責務の置き場所が、互いに絡み合うからです。
小さなアプリでは表面化しにくい問題ですが、業務要件や分析要件が増えた途端に苦しさが出ます。

RDBであれば、検索条件が増えたときも、結合、集約、並べ替え、条件分岐を比較的一つの問い合わせで扱えることがあります。
もちろん万能ではありませんが、少なくとも「どう取り出すか」をデータベース側で表現しやすい。
一方、Firestoreでは、あらかじめ想定した取得パターンに沿ってデータを配置しておく必要があります。
つまり、問い合わせの柔軟性よりも、事前設計への依存度が高いのです。
これは性能上の特性でもありますが、同時に設計上の硬さでもあります。

厳密に言えば、Firestoreが検索や集計をまったくできないわけではありません。
問題は、要件の変化に対して自然に拡張しにくいことです。
最初は簡単だった一覧画面が、あとから複数条件の絞り込み、管理者向けの横断検索、期間別集計、状態別の件数比較といった機能を求められたとき、データ構造とクエリの前提が一気に重くなります。
ここで重要なのは、検索や集計の不足が単独の機能問題ではなく、アーキテクチャ全体の再設計に波及しうる点です。

複数条件検索で設計が不自然になりやすい原因

Firestoreで複数条件検索が苦しくなるのは、検索の自由度が低いからというより、検索要件に合わせて保存構造を調整する必要が強いからです。
たとえば、商品一覧、求人一覧、投稿一覧のような画面では、通常は複数の条件を組み合わせて絞り込みたくなります。
カテゴリ、公開状態、地域、日付、価格帯、タグ。
RDBなら、適切なインデックス設計とSQLで段階的に対応しやすい場面です。
しかしFirestoreでは、検索条件の組み合わせが増えるほど、どのフィールドにどうインデックスを張るか、どの並び順を許容するか、どの条件を事前に潰して保存するかといった判断が増えます。

ここで不自然さが生まれます。
本来、検索条件は業務要件から自然に生まれるはずです。
ところがFirestoreでは、検索したいからデータ構造を変える、検索したいから表示用フィールドを追加する、検索したいから別コレクションを持つ、といった逆転現象が起きやすいのです。
要するに、業務モデルではなく検索制約がデータモデルを支配し始めます。
これは長期的には危険です。
なぜなら、新しい検索要件が出るたびに、設計の一貫性が崩れやすくなるからです。

たとえば、最初は公開中の投稿を日付順に出すだけだったものが、あとから地域別、人気順、タグ別、管理者用の非公開含む検索へ広がることがあります。
このとき、単に条件が増えたのではありません。
システムが必要とする見え方の種類が増えたのです。
Firestoreはこの「見え方の多様化」に弱い。
検索要件の進化が、そのまま構造の複雑化へつながりやすいからです。

集計処理をアプリケーション側へ逃がすことの問題点

Firestoreで検索や集計が難しくなったとき、よく起きる対処が「必要なデータをまとめて取って、アプリケーション側で処理する」という発想です。
小規模なデータ量であれば、たしかに動きます。
実装も一時的には分かりやすい。
しかし、この方針は多くの場合、将来の負債になります。

第一に、データ転送量と読み取り回数が増えます。
集計のために大量のドキュメントを取得し、それをサーバーやクライアントで処理する構造は、件数が増えた瞬間にコストと性能の両面で厳しくなります。
必要なのは件数だけなのに、元データ全体を読む。
これは非効率です。
しかもFirestoreでは読み取り自体が課金要素になるため、実装都合の遠回りがそのまま費用へ反映されます。

第二に、責務の分散です。
本来データベースに任せたい集計や抽出の役割をアプリケーションへ移すと、同じロジックが複数箇所に散らばりやすくなります。
管理画面ではサーバー側で集計し、ユーザー画面ではクライアント側で類似処理をし、バッチでは別実装を持つ。
こうなると、どれが正なのか分かりにくくなります。
数値が一致しない、タイミングでズレる、障害調査が難しい。
よくある崩れ方です。

第三に、遅延更新や事前集計という別の複雑さを呼び込みます。
集計が重いから、Cloud Functionsのような仕組みで書き込み時にカウンタを更新する。
この設計は一見賢く見えますが、失敗時の再実行、重複実行、整合性の担保といった新たな問題を持ち込みます。
集計を逃がしたつもりが、整合性と運用の難しさを抱え込むわけです。
処理場所の移動は、問題の消滅ではありません。
問題の変形です。

インデックス依存の運用が開発速度を鈍らせる場面

Firestoreでは、クエリとインデックス設計が密接に結びついています。
これは性能を安定させるための合理的な仕組みです。
しかし、要件が増えてくると、この仕組みが開発速度の足を引っ張ることがあります。
特に、検索条件や並び順の組み合わせが増える画面では顕著です。
画面追加や仕様変更のたびに、必要な複合インデックスを見直し、反映し、検証しなければなりません。
単なる実装ではなく、クエリごとに許された通路を整備する作業です。

問題なのは、このインデックス依存が局所的な最適化を誘発しやすい点です。
ある画面を成立させるために必要なインデックスを足していくうちに、全体としてどの検索要求をどの構造で支えているのかが見えにくくなります。
結果として、仕様変更に対して「この条件追加は実装だけで済むのか、それともデータ構造とインデックス戦略の再考が必要なのか」を毎回確認することになります。
この思考コストは無視できません。

整理すると、Firestoreでの検索要件拡張は、次の三層に影響します。

  • クエリ条件そのもの
  • 必要なインデックス定義
  • 取得しやすいように調整されたデータ構造

この三つが連動するため、変更の影響範囲が広くなります。
初期開発では速度が出るのに、中盤以降で鈍る理由はここです。
画面を増やすたびに、単なる機能追加ではなく、検索可能性の管理まで背負うことになる。
Firestoreが苦しくなるのは、機能不足だからではありません。
変化に対する構造的な粘りが弱いからです。
検索と集計が重要なシステムほど、その弱さは隠せません。

トランザクションと整合性の観点で見たFirestoreの限界

データ整合性とトランザクションの制約を示すシステム設計図

Firestoreを評価するとき、多くの人はクエリや開発速度には注目しますが、トランザクションと整合性の問題は後回しにしがちです。
しかし実務では、ここが最も深刻な分岐点になることがあります。
なぜなら、データベースは単に保存装置ではなく、業務ルールを破綻させないための基盤でもあるからです。
注文、在庫、課金、承認、予約。
こうした処理では、正しい値が保存されるだけでは足りません。
複数の操作が並行したときにも、矛盾しない結果になることが必要です。

Firestoreにもトランザクション機能はありますし、原子的な更新がまったく不可能なわけではありません。
問題は、RDBで自然に期待しがちな整合性モデルを、そのまま持ち込むと設計の前提が崩れやすいことです。
特に、複数ドキュメントにまたがる更新や、非正規化したデータの整合維持、クライアント主導の更新フローが絡む場面では、仕様上は成立していても運用上の説明が難しくなります。
ここで重要なのは、機能の有無ではなく、整合性を保つ責任の多くがアプリケーション側へ寄ってくることです。

整合性の議論は、派手ではありません。
しかし、障害や不具合が起きたときに最も表面化しやすい論点です。
値が一件ずれていた、表示と実態が食い違っていた、更新が一部だけ反映された。
ユーザーにとっては単なる不具合でも、開発側から見ると、整合性モデルの選択ミスであることが少なくありません。
Firestoreを使うかどうかは、この責任をどこまで自分たちで持てるかという問いでもあります。

RDBの感覚で整合性を考えると危険な理由

RDBに慣れていると、整合性はデータベースがかなり強く支えてくれるものだと感じやすいはずです。
正規化、外部キー、制約、トランザクション分離、結合による単一の正本管理。
もちろん設計を誤ればRDBでも問題は起きますが、少なくとも整合性維持のための道具立ては豊富です。
一方、Firestoreでは、その前提をそのまま持ち込むと危険です。
なぜなら、データを一つに保つよりも、読みやすい形へ複製して持つことが現実的な場面が多いからです。

この時点で、整合性の意味が変わります。
RDBでは「一つの正しい値を参照する」が基本ですが、Firestoreでは「複数箇所にある値を、どの程度の遅延や誤差を許容しつつ揃えるか」を考える場面が増えます。
これは単なる実装差ではありません。
整合性を強く保つ設計から、整合性のコストをどう配分するかという設計への転換です。
もしこの転換を意識せずにFirestoreを採用すると、見た目は動いていても、内部では一貫性の前提が崩れていきます。

たとえば、ある注文データと在庫データ、さらに商品表示用の集計値が別々のドキュメントに散らばっているとします。
このとき、RDB的な感覚では、一つのトランザクションで矛盾なく更新したいと考えるでしょう。
しかしFirestoreでは、更新フローや責務分担をかなり慎重に設計しないと、その自然な期待が実現しにくい場面があります。
つまり危険なのは、Firestoreに機能が足りないと思い込むことではなく、RDBと同じ発想で安全性が担保されると誤認することです。
前提の違い。
ここを外すと設計全体が甘くなります。

同時更新や部分失敗が業務ロジックを複雑にする仕組み

実務で整合性が崩れる典型的な場面は、同時更新と部分失敗です。
しかも厄介なのは、それらが単独で発生するとは限らないことです。
複数ユーザーが同時に操作し、同時にバックグラウンド処理も走り、そのどこかで一部だけ成功する。
こうした状況は、トラフィックが増えたシステムでは珍しくありません。
Firestoreのように、非正規化や複数ドキュメント更新を前提にしやすい環境では、この影響が業務ロジックへ直結します。

たとえば、あるアクションで次の更新が必要だとします。

  • 元データの状態変更
  • 一覧表示用ドキュメントの更新
  • 集計カウンタの加算
  • 通知用データの追加

この四つが常に完全同期で成功するならよいのですが、現実にはネットワーク、再試行、関数実行失敗、競合などが絡みます。
その結果、一部だけ反映される可能性を前提に設計しなければなりません。
すると業務ロジックは、単に成功時の処理を書くのではなく、失敗時に何を巻き戻すか、再実行しても二重計上しないか、途中状態をユーザーにどう見せるかまで含めて考える必要が出てきます。
ロジックの複雑化です。

しかも、こうした問題はテストで完全に捕まえにくい。
単体テストでは通る。
ローカルでも再現しない。
しかし本番で負荷がかかった瞬間、まれに崩れる。
これが最も厄介です。
業務ロジックの難しさは、コード量ではなく、例外系と競合時の振る舞いの数に比例します。
Firestoreはこの領域で、開発者に多くの判断を委ねます。
つまり、単純なCRUDに見えた処理が、実は分散状態遷移の問題に変わっていることがあるのです。

イベント駆動で補う設計が破綻しやすいケース

Firestoreの制約を補うために、イベント駆動の設計を採用することは珍しくありません。
あるドキュメントが更新されたら関数を起動し、別の集計や通知、派生データ更新を行う。
考え方としては自然ですし、うまくはまるケースもあります。
しかし、これを整合性の穴埋めとして多用し始めると、設計は急速に不安定になります。
なぜなら、イベント駆動は責務の分離に役立つ一方で、因果関係の追跡を難しくするからです。

特に破綻しやすいのは、ある更新が次の更新を呼び、その更新がさらに別の処理を起動するような連鎖構造です。
最初は便利でも、次第に依存が見えにくくなります。
どのデータがどのイベントで更新されるのか、失敗時にどこまで再実行されるのか、同じイベントが重複して走ったとき安全なのか。
この問いに即答できなくなった時点で、設計はかなり危うい。
イベント駆動は疎結合に見えて、実際には暗黙の結合を増やしやすい仕組みでもあります。

また、イベントは時間差を伴うことがあります。
つまり、整合性が即時ではなく最終的に揃えばよい、という前提を受け入れる必要がある。
しかし業務によっては、それが許されません。
たとえば在庫、決済、承認状態のように、いまこの瞬間の正しさが重要な領域では、遅延更新や非同期補正は説明責任を難しくします。
あとで揃うからよい、では済まない世界です。

イベント駆動は便利な道具ですが、整合性の代用品ではありません。
単純な通知や補助的な派生データ更新には向いていても、コアな業務不変条件を支える基盤として多用すると危険です。
Firestoreを中心に据えた設計で苦しくなるのは、こうした補助線がいつの間にか主構造へ昇格してしまうからです。
最初は回避策、後から中核。
そこに無理が生まれます。

Firestoreはなぜコストが読みにくいのか

Firestoreの課金要素が増えてコスト予測が難しくなる図解

Firestoreのコストを語るとき、「少量なら安い」「サーバー管理が不要だから総合的に得」といった説明がよく出てきます。
たしかに、初期段階ではそう見えることが多いです。
インフラ構築やDB運用の負担が軽く、少人数で早く立ち上げたい場面では合理的な選択肢になりえます。
しかし、私がFirestoreを慎重に見る理由の一つは、費用が単純な保存量だけで決まらず、アプリケーションの振る舞いそのものと強く結びついているからです。
しかも、その結びつきは開発初期には見えにくい。
ここが厄介です。

RDBの運用でも当然コストは発生しますが、少なくとも計算資源、保存容量、レプリカ構成など、比較的インフラ寄りの観点で把握しやすい面があります。
一方、Firestoreでは、どの画面で何件読むか、リアルタイム監視をどれだけ張るか、非正規化した結果どれだけ更新が増えるか、といったアプリケーション設計の選択が直接課金に跳ね返ります。
つまり、コスト最適化がインフラ運用の問題ではなく、データモデルとUI設計の問題になるのです。
これは開発体制によっては大きな負担です。

特に危険なのは、機能追加がそのままコスト増につながる構造を見落としやすいことです。
開発初期はユーザー数も少なく、画面も限られ、監視対象も単純です。
そのため「十分安い」と判断しがちです。
しかし、ユーザー数、表示要件、管理画面、通知、分析用途が増えたとき、どこで何件読まれているのかを後から追うのは簡単ではありません。
Firestoreは便利ですが、便利さの裏側で費用構造がアプリケーション内部に埋め込まれていく。
この性質を理解しないまま採用すると、後から説明の難しい請求と向き合うことになります。

読み取り回数ベースの課金が設計に与える影響

Firestoreのコストを読みにくくしている最大の要素は、読み取り回数が課金の中心にある点です。
これは単に「読めばお金がかかる」という話ではありません。
どのような画面設計をするか、どのような一覧取得を行うか、どの程度リアルタイム性を持たせるかによって、課金の増え方が大きく変わるということです。
つまり、設計判断がそのまま費用の増減に直結します。

たとえば、ある一覧画面で20件のドキュメントを表示するとします。
単純に見えますが、関連情報を別ドキュメントで持っていれば追加の読み取りが発生します。
ページ遷移時に再取得するのか、監視を継続するのか、フィルタ変更ごとに何件読み直すのか。
こうした細部の実装差が、回数ベース課金では無視できません。
RDBでも不必要なクエリは避けるべきですが、Firestoreではその設計上の粗さがより直接的に費用へ現れます。

さらに、読み取り回数ベースの課金は、開発者に「必要な表示のための自然な設計」ではなく、「いかに読まないかを意識した設計」を強く迫ります。
これは本来の業務要件とは別軸の最適化です。
たとえば、本当は詳細な一覧を出したいのに、課金を避けるために表示項目を削る。
あるいは、クライアントで気軽に参照したいのに、読む回数を減らすためだけに冗長なデータ複製を進める。
そうなると、設計の主導権が業務要件から課金モデルへ移ってしまいます。
技術選定として、これはあまり健全ではありません。

アクセス増加とともに見えにくいコストが膨らむ構造

Firestoreの費用が厄介なのは、ユーザー数が増えたら単純に比例して増える、という分かりやすい形だけではないことです。
実際には、アクセス増加に伴って機能も増え、取得頻度も増え、リアルタイム監視も増え、管理者向けの閲覧も追加され、バックグラウンド処理も膨らみます。
つまり、ユーザー増加が複数の経路から同時にコストを押し上げます。
この多重増幅が見えにくい。

たとえば、利用者が増えると次のような変化が起こりがちです。

  • 一覧画面のアクセス頻度が上がる
  • 通知やリアルタイム更新の対象件数が増える
  • 管理画面や分析用の読み取りが追加される
  • 派生データ更新や整合性維持のための処理が増える

この四つは別々に見えて、実際には互いに連動します。
しかも、Firestoreではデータ構造が読み取り効率に強く依存するため、負荷が増えてから設計を見直すと、単なるチューニングでは済まないことがあります。
データモデルの再配置、画面取得方式の変更、キャッシュ戦略の導入、監視の縮小。
つまり、コストの問題がアーキテクチャの問題へ変わるのです。

見えにくいというのは、単に請求明細が複雑という意味ではありません。
どの機能がどれだけ費用を押し上げているのかを、仕様レベルで説明しづらいということです。
これが開発現場ではかなりつらい。
費用削減の議論をしたくても、原因が単一ではないため、部分最適化が全体にどう効くか読みづらいからです。

小規模では安く見えても中規模以降で判断を誤る理由

Firestoreが小規模で魅力的に見えるのは自然です。
実装が速い。
管理が軽い。
最初の利用量も少ない。
そのため、費用対効果が非常によく見えます。
問題は、その初期印象を将来にもそのまま延長してしまうことです。
これはよくある判断ミスです。
小規模での効率が、中規模以降でも続くとは限りません。
むしろ、多くの場合そこで前提が変わります。

小規模では、要件が単純です。
検索条件も少ない。
監視対象も限定的です。
管理画面も簡素で、分析要件も弱い。
そのため、読み取り回数や更新回数が爆発しにくい。
ところが中規模になると、機能が増えます。
複数画面から同じデータを見たくなる。
ユーザー属性別の表示が増える。
運用者向けの確認画面も要る。
ログ的な閲覧やサポート用途の参照も発生する。
ここで、初期には存在しなかった読み取りパターンが大量に生まれます。

この変化が危険なのは、増えたコストが「利用者数が増えたから当然」と見えてしまいやすい点です。
実際には、単なる利用者増加ではなく、設計と課金モデルの相性が悪化している場合もあります。
つまり、スケールした結果ではなく、スケールしたときに不利になる設計を最初に選んでいた可能性があるわけです。
この区別ができないと、Firestore自体のコストなのか、設計上の無理なのかを見誤ります。

整理すると、Firestoreの費用を正しく見るには、現在の利用量ではなく、将来の取得パターンの増え方を見なければなりません。
今いくらか、ではなく、要件が増えたらどこが課金点になるか。
その見通しです。
小規模の成功体験は魅力的ですが、技術選定はそこだけで決めるべきではありません。
安く始められることと、健全に伸ばせることは別問題です。
ここを分けて考えられるかどうかが、後の差になります。

セキュリティルールと権限制御が難しくなる本当の理由

Firestoreの権限制御ルールが複雑化する様子を示す概念図

Firestoreを採用するとき、多くの人はセキュリティルールを「便利なアクセス制御機能」として理解します。
たしかに、クライアントから直接データベースへアクセスする構成でも、読み書きの許可条件を細かく定義できる点は大きな利点です。
サーバーAPIを必ずしも厚く作らなくても、一定水準の保護をかけられる。
この設計思想自体は合理的です。
しかし、実務で本当に難しくなるのは、ルールを書けるかどうかではありません。
業務ロジックと認可ロジックがどのように分散し、その関係を誰が把握できるかという問題です。

権限制御は、本来アプリケーションの中心的な責務です。
誰が何を見られるのか。
誰がどの条件で更新できるのか。
どの状態遷移が許されるのか。
これらはUIの都合でもDBの都合でもなく、システムの規則そのものです。
ところがFirestoreでは、クライアントSDK、データ構造、セキュリティルール、必要に応じてサーバー側の補助処理が、それぞれ別の層として存在します。
その結果、権限に関する知識が一か所にまとまらず、暗黙の前提が増えやすくなります。
ここが難所です。

さらに厄介なのは、セキュリティルールが「業務ルールのすべて」を自然に表現する場ではないという点です。
単純な所有者判定や属性ベースの制御には向いていても、状態遷移、複数エンティティ間の整合条件、時間や履歴に依存する判断などが増えると、設計が急速に見通しを失います。
つまり、セキュリティルールは便利な仕組みである一方、権限制御の全責任を美しく引き受けてくれるわけではないのです。
このズレを理解せずに採用すると、気づいたときには「どこで何が守られているのか説明しにくい」システムになってしまいます。

アプリケーションロジックと認可ルールが分断される問題

Firestoreの権限制御が難しい最大の理由は、認可がアプリケーションコードの外側にも存在することです。
たとえば、画面上ではボタンを非表示にしていても、最終的な可否判定はセキュリティルールに委ねられます。
これは安全上は正しい考え方です。
しかし同時に、業務ロジックと認可ロジックが別の表現系に分かれてしまうことを意味します。
UIにはUIの条件分岐があり、クライアント処理には事前チェックがあり、Firestoreには最終防衛線としてのルールがある。
この三層が一致していなければ、不整合が起きます。

分断の問題は、単にコードが別ファイルにあるという話ではありません。
責務の重なり方が曖昧になることです。
たとえば「自分が作成した下書きだけ編集できる」という要件は比較的単純ですが、これに「公開後は管理者のみ変更可能」「締切後は誰も更新できない」「一部の項目だけは別権限」といった条件が加わると、どこまでをUIで表現し、どこまでをアプリケーションロジックで判断し、どこをルールで保証するのかが難しくなります。
しかも、これらが同じ一つの仕様を別々の場所で表現している。
設計負荷です。

RDB中心のサーバーサイドAPI構成であれば、認可を比較的一か所に寄せやすいことがあります。
一方Firestoreのクライアント直結型では、速度と簡潔さを得る代わりに、認可モデルが分散しやすい。
このトレードオフを軽く見てはいけません。
保守性の観点では、ロジックが正しいこと以上に、どこに正しさが書かれているかが重要だからです。

ルールの見通しが悪くなると何が起きるのか

セキュリティルールが複雑になってくると、問題は性能や記述量だけではなくなります。
本当に危険なのは、誰が見ても全体像を説明しにくくなることです。
ルールの見通しが悪いというのは、単に長いという意味ではありません。
例外条件、ネストした判定、コレクションごとの条件差、派生的な前提が増え、変更時の影響範囲を直感的に把握できない状態を指します。

こうなると、まず起きるのは変更への恐れです。
新しい画面を追加したい、管理者権限を増やしたい、公開条件を少し変えたい。
そうした自然な改善に対して、「この変更で他のアクセス権を壊さないか」が見えなくなります。
結果として、必要以上に保守的になるか、逆に十分な検証なしに変更して事故を起こすかのどちらかになりやすい。
どちらも好ましくありません。

次に起きやすいのが、意図しない許可や拒否です。
これは非常に厄介です。
許可漏れなら画面が動かず気づきやすい場合もありますが、意図しない許可は運が悪いと長く潜伏します。
しかもFirestoreのルールは、アプリケーションコードとは別の文脈で書かれるため、普段の機能開発のレビューから漏れやすいことがあります。
業務ロジック変更が認可条件に影響していたのに、片方しか更新されない。
現場では起こりがちな崩れ方です。

見通しの悪さは、設計の透明性を奪います。
透明性が失われると、チーム内で「本当は誰がどこまでアクセスできるのか」が共有されにくくなる。
すると不具合修正も仕様議論も遅くなります。
権限制御は安全性のための仕組みですが、見通しを失うと開発速度そのものを落とす要因になります。
守れているかどうか以前に、説明できるかどうか。
この観点が重要です。

テストしにくい権限制御が品質に与える悪影響

権限制御の難しさは、実装時よりむしろテスト時に強く表れます。
機能の正しさは、通常の単体テストや結合テストである程度確認できます。
しかし認可は、ユーザー属性、データ状態、更新対象、時刻、関係する他データなど、複数条件の組み合わせで成立することが多いため、網羅性の確保が急激に難しくなります。
しかもFirestoreでは、その判定の一部がセキュリティルール側にあるため、通常のアプリケーションテストだけでは不十分になりやすいのです。

問題は、テストケースの数が増えることだけではありません。
失敗の原因が分かりにくいことです。
ある更新が拒否されたとき、それはUI条件か、クライアントの前処理か、データの状態か、Firestoreルールか。
切り分けに時間がかかります。
さらに、権限テストは正常系より異常系のほうが重要です。
本来できてはいけない操作が本当に拒否されるか。
境界条件で抜け穴がないか。
ここを丁寧に見る必要がありますが、分散した認可モデルでは確認対象が増えます。

品質面で深刻なのは、認可の欠陥が機能不具合より重大になりやすいことです。
表示崩れや軽微なバグなら影響は限定的でも、権限漏れは情報漏えいや不正更新につながる可能性があります。
一方で、過剰に厳しいルールも業務停止を招きます。
つまり、緩すぎても厳しすぎても問題です。
このバランスを高品質で保つには、仕様の明確さ、一貫した責務分担、十分なテスト戦略が必要になります。

整理すると、Firestoreのセキュリティルールが難しいのは、文法が特殊だからではありません。
認可がシステムの複数層にまたがり、変更と検証の負荷が積み上がりやすいからです。
権限制御は後付けの設定ではなく、設計の中核です。
ここを軽く扱うと、機能が増えるほど品質保証の難度が上がります。
便利な仕組みの裏にある、説明責任と検証責任。
その重さです。

実務でFirestoreを避けたほうがよいシステムの特徴

Firestore非推奨となる業務システムの特徴を整理した構成図

Firestoreは便利な技術ですが、便利であることと、あらゆるシステムに向いていることは同義ではありません。
実務で重要なのは、技術の強みを知ること以上に、どの条件下で苦しくなるかを見極めることです。
特に、システムが単なる情報表示ではなく、業務ルール、履歴管理、分析、承認、集計、監査性といった要件を持ち始めると、Firestoreの特性は長所より制約として表れやすくなります。
ここで無理に使い続けると、目先の実装速度と引き換えに、将来の変更コストを膨らませることになります。

私がFirestoreを避けたほうがよいと考えるシステムには共通点があります。
それは、データの正しさ、検索の柔軟性、関係性の豊かさ、長期運用時の説明可能性が重要であることです。
こうしたシステムでは、単純なCRUDの速さよりも、整合性と変更容易性が価値になります。
Firestoreはこの領域でまったく使えないわけではありません。
しかし、多くの場合、その実現には非正規化、補助コレクション、イベント駆動、事前集計、複雑な権限制御といった追加の工夫が必要になります。
つまり、技術選定の時点では簡単そうに見えても、運用フェーズでは複雑性を前借りする構図になりやすいのです。

避けるべきかどうかの判断は、機能の有無だけで決まりません。
重要なのは、要件が伸びたときに設計が自然に耐えられるかどうかです。
今は小さく見える要件でも、将来の拡張で何が起きるか。
その想像力が技術選定では不可欠です。

業務システムや基幹データ管理と相性が悪い理由

業務システムや基幹データ管理では、データの一貫性、更新履歴、権限、監査性、例外処理といった要素が中心になります。
ここで重要なのは、単に保存できることではなく、なぜその値になっているかを追跡できることです。
たとえば受発注、在庫、承認、請求、会員管理のようなシステムでは、ある更新が誰によって、どの条件で、どの時点に行われたかを説明できなければ困ります。
これは機能要件であると同時に、運用要件でもあります。

Firestoreがこうした領域で苦しくなりやすいのは、データの関係性や整合性をアプリケーション側で強く管理する必要があるからです。
RDBなら、外部キーや制約、トランザクション設計を通じて、一貫性の担保を比較的構造化しやすい。
一方Firestoreでは、表示効率や取得効率のためにデータを複製しやすく、その結果として更新責務が分散しやすい。
業務システムではこの分散が致命的になることがあります。
なぜなら、見た目の正しさではなく、内部状態の説明可能性が求められるからです。

また、基幹系では後から想定外の確認が必要になることが珍しくありません。
ある期間の異常値だけ見たい、特定条件の組み合わせで抽出したい、関連データをまたいで監査したい。
こうした要求に対し、Firestore中心の設計は柔軟に応じにくい場面があります。
つまり、日常業務を回せるかではなく、例外時に耐えられるかが問われるのです。
基幹系との相性を考えるなら、平常時の快適さより、異常時の強さを見るべきです。

分析基盤やレポーティング要件で苦戦しやすい背景

Firestoreが分析基盤やレポーティングに向きにくい理由は明快です。
分析では、保存されたデータをさまざまな切り口で横断し、集計し、比較し、傾向を見ることが求められます。
ここで重要なのは、読みやすく保存されていることよりも、後から多様な問いを立てられることです。
しかしFirestoreは、アクセスパターンを先読みして保存構造を寄せる設計になりやすく、未知の分析要求に柔軟に応えるには不利です。

たとえば、売上を日別、商品別、顧客属性別、流入経路別に見たい、あるいは特定期間中の状態遷移を追いたいとします。
こうした要求は、最初からすべてを想定するのが難しい。
しかも分析では、途中で「やはり別軸でも見たい」という追加要求がよく出ます。
RDBや分析基盤向けの仕組みであれば、この種の問いに比較的自然に対応できますが、Firestoreでは事前集計や補助データが必要になりやすい。
つまり、分析要件が増えるほど、そのたびに派生データ設計を足していく構図になります。

これは単に面倒というだけではありません。
分析結果の信頼性にも影響します。
集計ロジックが複数箇所へ分散し、更新タイミングがずれ、どの数値がどの時点の真実を表しているのか分かりにくくなるからです。
経営判断や運用判断に使うレポートでは、これはかなり危険です。
分析とは、見られることだけでなく、信頼してよいことが重要です。
Firestore中心の設計では、この信頼性を維持するために余分な仕組みが必要になりやすいのです。

将来的な機能追加を見据えると設計負債になりやすいケース

Firestoreが設計負債になりやすいのは、最初の構造が悪いからだけではありません。
むしろ、初期設計としては合理的でも、機能追加の方向と噛み合わなくなると急に苦しくなることがあります。
ここが難しいところです。
開発初期には、要件が限定的で、表示画面も単純で、更新の流れも少ない。
そのため、Firestoreの素早さと柔軟さが非常に魅力的に映ります。
しかし、プロダクトは止まりません。
検索が増える。
権限が増える。
管理画面が増える。
通知や履歴や分析が必要になる。
すると、最初は賢く見えた近道が、後半では遠回りになります。

設計負債になりやすいケースにはいくつかの特徴があります。

  • 初期段階で画面都合に強く寄せたデータ構造
  • 同じ意味のデータを複数箇所へ持つ非正規化前提
  • 集計や検索を後から追加する想定が弱い設計
  • 権限制御や状態遷移が将来複雑になる可能性が高い領域

このような条件が重なると、機能追加のたびに局所的な補修が必要になります。
新しい画面のために別コレクションを足す。
新しい条件検索のために派生データを増やす。
権限差分のために認可ロジックを継ぎ足す。
結果として、全体像の説明が難しいシステムになっていきます。
これはまさに設計負債です。
コードの汚さだけではなく、構造的な変更コストの増大です。

将来の機能追加を完全に予測することはできません。
ただし、変化が起きる前提で、どの種類の変化に強い技術かは考えられます。
Firestoreは、限定された取得パターンと単純な業務ルールの範囲では非常に強い。
一方で、要件が横に広がるタイプのシステムでは、次第に設計の粘りが弱くなります。
短く作る技術と、長く耐える技術。
その違いを見極めることが大切です。

Firestoreの代替として検討したいデータベース設計の選択肢

Firestoreの代替候補となるデータベース設計を比較するイメージ

Firestoreを使わないという判断は、そのまま「古い技術に戻るべきだ」という意味ではありません。
重要なのは、Firestoreを外したあとに何を選ぶかではなく、どのような設計思想で選ぶかです。
技術選定で失敗しやすいのは、ある製品やサービスの名前を先に決めてしまい、その後で要件を当てはめようとすることです。
本来は逆です。
まず、データの整合性、検索の柔軟性、更新頻度、リアルタイム性、分析要件、権限制御、将来の変更可能性を整理し、それに対してどの方式が自然に応えられるかを考えるべきです。

Firestoreは、特定の条件下では非常に合理的な選択肢です。
しかし、実務では「初期開発が速いこと」だけでは足りません。
後から検索条件が増える、権限が複雑化する、集計が必要になる、他システムとの連携が増える。
このような変化に耐えるには、単なる導入のしやすさより、変更に対する構造的な強さが求められます。
そこで重要になるのが、RDBを軸にするか、別のNoSQLを用途限定で使うか、あるいは複数のストレージを責務分離して組み合わせるかという発想です。
単一の正解ではなく、要件ごとの最適化。
その視点です。

代替案を考えるときは、「Firestoreより高機能な何か」を探すのではなく、「どの問題をどこで解くのが自然か」を問うべきです。
データベースの比較は、機能一覧の勝負ではありません。
設計負荷の置き場所の比較です。
何をDBに担わせ、何をアプリケーションに担わせるか。
その境界設計こそが本質です。

RDBを選ぶべき条件とその判断基準

私がRDBを第一候補として考えるのは、単に昔から使われているからではありません。
データ同士の関係が豊富で、後から検索条件や集計要件が増えやすく、整合性の説明責任が重いシステムでは、RDBの構造が自然に強いからです。
正規化、制約、結合、トランザクション、インデックス設計。
これらは面倒に見えることもありますが、長期運用では「面倒を最初に引き受ける代わりに、後で破綻しにくくする仕組み」として働きます。

RDBを選ぶべき条件は、おおむね次のように整理できます。

  • 複数エンティティ間の関係が重要である
  • 一貫した更新と整合性維持が重要である
  • 条件検索や集計が将来的に増える可能性が高い
  • 管理画面、分析、監査、レポート要件がある
  • 将来的な仕様変更に備えて柔軟な問い合わせ能力が必要である

逆に言えば、これらの要件が薄く、単純な読み書きとリアルタイム性が中心なら、RDBを重く感じる場面もあるでしょう。
しかし、業務システムや中長期運用を前提とするサービスでは、RDBの強みは単なる機能ではなく、設計の秩序そのものです。
秩序があるから変更しやすい。
ここは誤解されやすい点です。
自由度が高いほど変更に強いわけではありません。
むしろ、変更のたびに構造の整合性を保てる仕組みがあるほうが強いのです。

判断基準として見るべきなのは、今の画面を作れるかではなく、半年後に別の見方を要求されたとき自然に応えられるかです。
そこまで含めて考えるなら、RDBは依然として非常に有力です。

用途に応じてNoSQLを使い分けるという発想

Firestoreを避けるからといって、NoSQL全般を否定する必要はありません。
むしろ大切なのは、NoSQLを「RDBの代用品」ではなく、「特定の性質に強い道具」として使い分けることです。
ここを混同すると、技術選定が極端になりやすい。
NoSQLが悪いのではなく、責務の切り分けなく万能用途に使おうとすることが問題なのです。

NoSQLにはそれぞれ得意分野があります。
キーバリュー型は高速な単純参照に向いていますし、ドキュメント型は表示都合に寄せた柔軟な保存に向いています。
時系列データに強いもの、検索に強いもの、キャッシュ用途に適したものもあります。
重要なのは、業務の正本データまで同じ思想で押し通さないことです。
たとえば、正本はRDBで管理しつつ、高速表示用キャッシュや全文検索用インデックス、分析用ストアを別に持つ設計は十分ありえます。
この分離は複雑に見えますが、役割が明確ならむしろ健全です。

よくないのは、最初から一つのストレージにあらゆる責務を背負わせることです。
書き込み、読み出し、検索、集計、通知、分析、権限制御。
そのすべてを一つの仕組みで賄おうとすると、いずれどこかで無理が出ます。
用途に応じてNoSQLを使い分けるという発想は、技術を増やすこと自体が目的ではありません。
責務を明確にし、各ストレージを得意分野で使うための設計です。
ここを理解すると、Firestoreを中心に据えるかどうかの判断もかなり冷静になります。

技術選定で見るべきは機能ではなく将来の変更容易性

技術選定の議論では、どうしても「何ができるか」に目が向きます。
リアルタイム同期がある、SDKが充実している、サーバーレスで始めやすい、マネージドで運用が楽。
どれも事実でしょう。
しかし、本当に見るべきなのは、今できることより、将来変えたいことにどれだけ耐えられるかです。
実務のシステムは完成品ではありません。
公開後に要件が増え、使い方が変わり、想定外の運用課題が出ます。
したがって、優れた技術とは、初期構築が速い技術というより、変更時の破壊範囲が小さい技術です。

この観点で考えると、選定時に問うべきは次のような内容になります。

観点 問うべき内容 重視する理由
検索拡張性 条件が増えたとき自然に対応できるか 要件追加で破綻しやすいため
整合性 更新責務をどこまで一元化できるか 業務ロジックの信頼性に直結するため
保守性 構造変更の影響範囲を説明しやすいか 長期運用での改修効率に関わるため
可観測性 障害時に何が起きたか追跡しやすいか 不具合調査と再発防止に必要なため

この表が示す通り、選定基準は派手な機能比較ではありません。
むしろ、変化したときにどれだけ説明可能で、修正可能で、再設計しやすいかという地味な部分です。
Firestoreが魅力的に見える場面でも、この視点で眺めると評価は変わります。
最初に作りやすいか。
後から壊れにくいか。
両者はしばしば一致しません。

技術選定とは、現在の要件に答える作業であると同時に、未来の変更に備える作業でもあります。
だからこそ、機能一覧や導入体験だけで決めるべきではありません。
将来の変更容易性。
これこそが、Firestoreの代替案を考えるうえで最も重要な判断基準です。

なぜ私はFirestoreを使わないのかを設計視点で総括する

Firestoreを使わない理由を設計視点で総括する記事まとめのイメージ

私がFirestoreを使わないと判断する理由は、単に苦手意識があるからでも、流行に逆張りしたいからでもありません。
設計という観点から見たとき、Firestoreが得意とする問題領域と、私が長く保守したいシステムの要件とが、しばしば一致しないからです。
ここでいう設計とは、画面が動くことだけではなく、データの意味、責務の境界、変更時の影響範囲、障害時の説明可能性、将来の機能追加に対する耐性まで含んだものです。
つまり、初期実装のしやすさよりも、時間が経ってから破綻しにくいことを重視した判断です。

Firestoreはたしかに魅力的です。
リアルタイム同期がしやすい。
クライアントとの接続が近い。
初期開発の速度が出やすい。
小さなアプリや、アクセスパターンが比較的単純なサービスでは、非常に合理的に機能するでしょう。
この点は否定しません。
むしろ、その魅力が本物であるからこそ、多くの開発者が惹かれます。
ただし、魅力があることと、長期的な基盤として適していることは別問題です。
私は後者の観点で見ています。

設計視点でFirestoreを慎重に見る最大の理由は、問題の所在が後ろにずれやすいことです。
導入初期には、扱いやすさが前面に出ます。
データは保存できる。
画面も動く。
同期も便利。
ところが、要件が広がり始めると、検索、集計、整合性、権限制御、コスト予測、監査性といった論点が次々に前景化します。
そして厄介なのは、それらが独立した問題ではなく、データモデルと密接に結びついていることです。
検索を増やせば構造を変えたくなる。
構造を変えれば整合性の管理が難しくなる。
整合性を補おうとすればイベント駆動や補助的な更新処理が増える。
結果として、最初は簡単だったはずの構成が、後から説明しにくい複合体へ変わっていきます。

私は技術選定において、「今できること」よりも「後から変えられること」を重視します。
なぜなら、実務のシステムは必ず変わるからです。
最初に想定したユースケースのままで終わることはほとんどありません。
検索条件は増えます。
表示要件も増えます。
権限も細かくなります。
分析やレポートの必要も出てきます。
すると、初期段階では合理的だった設計が、将来の拡張に対して障害物になることがあります。
Firestoreはまさにこの種の問題を抱えやすい。
これは機能不足というより、変化に対して構造的な粘りが弱いという評価です。

私が設計上とくに重視しているのは、次の四点です。

  • データ同士の関係を無理なく表現できること
  • 要件追加に対して検索や取得方法を自然に拡張できること
  • 整合性と更新責務を一貫した形で説明できること
  • 障害時や仕様変更時に、影響範囲を追跡しやすいこと

Firestoreは、これらすべてを絶対に満たせないわけではありません。
しかし、多くの場合、それを実現するためにはアプリケーション側の工夫が大きくなります。
非正規化、派生データ、補助コレクション、関数による非同期更新、複雑なセキュリティルール。
こうした仕組みを積み重ねることで一応の形にはできますが、その時点で「Firestoreだから簡単」という導入理由はほぼ失われています。
にもかかわらず、RDBのような問い合わせ柔軟性や一貫性モデルをそのまま得られるわけではありません。
ここに設計上の割に合わなさを感じます。

もちろん、Firestoreを選ぶべき場面はあります。
単純なデータ構造、リアルタイム性の価値が高い用途、短期間での検証、クライアント中心の小規模アプリ。
このような条件では合理的です。
しかし、私が普段重視するのは、成長して複雑になるシステムです。
そのようなシステムでは、最初に速く作れることよりも、後から苦しまないことのほうが重要です。
設計とは、いま楽をするための技巧ではなく、未来の混乱を減らすための準備でもあります。

技術選定の議論では、しばしば「何ができるか」が中心になります。
ですが、本当に問うべきは「どんな変更が入っても、どこまで自然に耐えられるか」です。
Firestoreは、一定範囲の問題には強い。
しかし、複雑な業務要件や長期保守を前提とする設計では、制約を後から回収する負担が大きくなりやすい。
だから私は選ばないのです。

結局のところ、私がFirestoreを使わない理由は、嫌いだからではありません。
便利さの代償として、どこに複雑さが移るのかを考えた結果です。
初期開発の速度を取る代わりに、後半の設計自由度を失いやすい。
クライアントの実装を軽くする代わりに、データモデルと整合性管理を重くしやすい。
見た目の単純さを取る代わりに、変更時の説明責任を複雑にしやすい。
この交換条件を冷静に評価したとき、私が長く保守したいシステムでは、別の選択肢のほうが合理的だと判断します。

使えるかどうかではなく、どの痛みを将来引き受けるか。
その設計上の選択として、私はFirestoreを使わない。
それが結論です。

コメント

タイトルとURLをコピーしました