Firebase: what it is, main tools and capabilities

What is Firebase

Firebase is a Google platform that provides a set of cloud services for developing mobile and web applications. Firebase was founded in 2011 as a startup offering a Realtime Database with real-time data synchronization. In 2014, Google acquired Firebase for approximately $300 million, and since then the platform has evolved into a comprehensive ecosystem of over 20 services for all stages of application development.

Firebase solves three main challenges of mobile development: building a backend without managing servers (Firestore, Cloud Functions, Hosting), monitoring and analytics (Analytics, Crashlytics, Performance Monitoring), and user-facing services (Authentication, Cloud Messaging, Remote Config). According to Google (2025), the Firebase SDK is installed on over 3 billion devices worldwide. The platform supports Android, iOS, Web, Unity, and Flutter, making it a cross-platform solution for projects of any scale, from startups to large enterprises. The free Spark plan allows you to start using Firebase without financial investment, which is especially important for indie developers and small studios at the prototyping and product launch stage.

Core Firebase Services

Firebase includes over 20 services divided into three categories. Each category addresses specific development challenges, from backend creation to user engagement.

Build Category Services

The “Build” category includes services for backend creation: Firestore (NoSQL database), Authentication (sign-in via email, Google, Apple, Facebook), Cloud Storage (file storage), Cloud Functions (serverless functions), Realtime Database (real-time database), and Hosting (web content hosting).

Release and Engage Category Services

The “Release & Monitor” category includes services for testing and monitoring: Crashlytics (real-time crash reporting), Performance Monitoring (performance measurement), Test Lab (testing on real devices in Google Cloud), and App Distribution (distributing test builds). The “Engage” category includes services for user engagement: Cloud Messaging (push notifications), In-App Messaging (in-app messages), Remote Config (remote configuration), and A/B Testing (experiments). Analytics is the central service that connects all the others — data from Crashlytics, Cloud Messaging, and A/B Testing is automatically sent to Analytics to build a complete picture of user behavior.

Firebase SDK: Setup and Configuration

Connecting Firebase to your application starts with registering a project in the Firebase Console (console.firebase.google.com). After registration, Firebase generates a configuration file: google-services.json for Android or GoogleService-Info.plist for iOS. For Android, you need to add the Google Services plugin to the build.gradle file at the project level and apply it in the app module.

An example of basic Firebase setup for an Android application in Kotlin demonstrates the minimal configuration in the build.gradle files (Project and App level), as well as Firebase initialization in the application code:

// build.gradle (Project level)
buildscript {
    dependencies {
        classpath "com.google.gms:google-services:4.4.2"
    }
}

// build.gradle (App level)
plugins {
    id "com.google.gms.google-services"
}
dependencies {
    implementation "com.google.firebase:firebase-analytics:22.1.0"
    implementation "com.google.firebase:firebase-firestore:25.1.0"
    implementation "com.google.firebase:firebase-auth:23.1.0"
}

// Application.kt
import com.google.firebase.FirebaseApp
import com.google.firebase.analytics.FirebaseAnalytics

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        FirebaseApp.initializeApp(this)
        val analytics = FirebaseAnalytics.getInstance(this)
    }
}

The code shows three parts of the setup: adding the Google Services plugin in the root build.gradle, adding Firebase dependencies in the app module (analytics, firestore, auth), and initializing Firebase in the Application class. After setup, Firebase automatically starts collecting analytics: user sessions, screens, events, and demographic data without additional code. Configuration through Remote Config allows you to change application behavior remotely without publishing an update through the store. For iOS, the setup process is similar: you need to add GoogleService-Info.plist to the project and call FirebaseApp.configure() in AppDelegate.

Analytics and Crashlytics

Firebase Analytics is a free analytics service with unlimited tracked events. Analytics collects data about users, sessions, purchases, and conversions, and also automatically logs events such as first launch, app updates, and interactions with push notifications. Integration with Google Ads allows you to track advertising campaign effectiveness and optimize user acquisition costs.

Firebase Analytics: Key Features

Firebase Analytics provides reports on user retention, cohort analysis, conversion funnels, and audience segmentation by demographics, interests, and behavior. All events are free and have no quantity limits. Data is available in real time in the Firebase Console with a delay of no more than 2–4 hours for standard reports.

Crashlytics: Crash Monitoring

Crashlytics is a real-time crash monitoring service. Crashlytics automatically collects crash reports with full stack traces, device state, OS version, and the sequence of user actions before the crash. According to Firebase (2025), Crashlytics identifies the root cause of a crash automatically in 85% of cases, reducing diagnosis time from hours to minutes. The service groups crashes by type and shows trends — whether the number of crashes is increasing after the latest update or remaining stable.

An example of logging a custom event in Firebase Analytics on Kotlin shows how to track key user actions in the application:

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.logEvent

class AnalyticsTracker {
    private lateinit var analytics: FirebaseAnalytics

    fun trackPurchase(itemId: String, price: Double) {
        analytics.logEvent(FirebaseAnalytics.Event.PURCHASE) {
            param(FirebaseAnalytics.Param.ITEM_ID, itemId)
            param(FirebaseAnalytics.Param.PRICE, price)
        }
    }
}

The code logs a purchase event with an item ID and price. Firebase Analytics automatically associates the event with the current user and session, allowing you to build conversion funnels, cohort analysis, and retention reports without additional setup. Analytics data is updated in real time in the Firebase Console and is available for export to BigQuery for in-depth analysis using SQL queries. Thanks to integration with Google Ads, you can track the full cycle from ad impression to the target action in the app and optimize ad campaigns based on user behavior data.

Firestore and Realtime Database

Firebase offers two databases: Cloud Firestore (recommended) and Realtime Database (legacy). The choice between them depends on the project’s requirements for scaling, query complexity, and data modeling.

Cloud Firestore

Cloud Firestore is a NoSQL document database with automatic synchronization between devices, offline support, and scaling without developer intervention. Data is stored in documents organized into collections, which simplifies structuring and querying compared to the Realtime Database node tree.

Firestore vs. Realtime Database

The main differences between Firestore and Realtime Database: Firestore supports complex queries with filtering by multiple fields, sorting, and limits, while Realtime Database requires client-side sorting for complex queries. Firestore automatically scales to millions of simultaneous connections, while Realtime Database is limited to 200,000 concurrent connections. Firestore uses a more intuitive security model based on path matching and security rules, reducing the risk of configuration errors.

An example of working with Cloud Firestore on Kotlin shows writing and reading data in a users collection:

import com.google.firebase.firestore.FirebaseFirestore
import com.google.firebase.firestore.SetOptions

data class User(
    val name: String = "",
    val email: String = ""
)

class UserRepository {
    private val db = FirebaseFirestore.getInstance()

    fun saveUser(userId: String, user: User) {
        db.collection("users")
            .document(userId)
            .set(user, SetOptions.merge())
    }

    fun loadUser(userId: String) {
        db.collection("users")
            .document(userId)
            .get()
            .addOnSuccessListener { doc ->
                val user = doc.toObject(User::class.java)
            }
    }
}

The code defines a data class User and a UserRepository class with saveUser and loadUser methods for working with the “users” collection in Firestore. The save method uses SetOptions.merge for partial document updates without overwriting existing fields. The load method performs asynchronous document reading via get with an onSuccessListener callback. Firestore automatically synchronizes changes between devices through listeners (SnapshotListener), enabling real-time applications without additional WebSocket infrastructure. This architecture simplifies the development of chats, activity feeds, and other features that require instant data updates across all user devices.