⟐ Dev Tools/2026-03-30Advanced

Firebase Genkit × Gemini API in Production — Design Choices and Gotchas from a Month of Indie Backend Work

Field notes from a month of running Firebase Genkit and Gemini API behind an indie app review-summarization backend. Flow and Tool design, Cloud Functions vs. Cloud Run, real cost and latency numbers, and seven undocumented gotchas.

Firebase GenkitGemini API²⁴⁹ RAG¹⁴Cloud FunctionsCloud Run⁵ Agents⁸ Production³³ AI Development⁴

✦ Premium Article

I started wiring Firebase Genkit into the back end of my indie apps in early 2026. The first thing I shipped was a small Flow that summarized user reviews into a dashboard. That alone replaced about eighty lines of Cloud Functions code I had been maintaining for two years — the usual "call Gemini, watch the token budget, format the result, log to Firestore" routine — with a single defineFlow call. I sat at my desk for a while just looking at the diff.

When you run an indie backend, evaluation collapses into two questions: how many seconds does the user wait, and what does the invoice say at the end of the month. On apps funded by ad revenue, both of those land directly on the bottom line. So when I looked at Genkit, I skipped the feature list and watched only those two numbers.

What follows is the notebook from running that review-summarization Flow in production for a month. It covers the fundamentals — Flow design, Tool composition, RAG, deployment, security — and then the parts the docs do not warn you about: where it actually hurts, and what the real cost and latency numbers looked like.

One caveat up front. The measurements were taken in April 2026. The model lineup has turned over since, and the same word "Flash" now carries a very different unit price. Carrying those dollar figures around unchanged will trip you up, so there is a later section on how to re-derive them.

Understanding Firebase Genkit: Core Concepts and Advantages

Firebase Genkit consolidates the fragmented landscape of LLM integration patterns into a unified abstraction called the Flow. Rather than juggling PromptTemplate classes, Chain objects, and Agent frameworks from different libraries, Genkit provides a consistent mental model that scales from simple text generation to complex multi-step autonomous systems.

The Three Core Abstractions

Flows are the fundamental unit of AI computation. Each Flow has:

Type-safe inputs and outputs: Defined via Zod schemas, ensuring compile-time correctness and IDE autocomplete support
Built-in streaming: Native support for real-time response streaming, critical for modern UX where users expect immediate feedback
Automatic tracing: Every API call, intermediate result, and error is captured automatically, transforming production debugging from guesswork into forensic analysis
Composability: Flows can call other Flows, enabling modular architecture and code reuse

Tools are discrete actions that Flows invoke—API calls, database queries, file system operations. Gemini's built-in tool calling capability means the model itself decides which Tools to use and in what sequence, creating truly autonomous behavior.

Prompts are templated instructions with variable injection. They're more than simple strings; they're structured definitions that can include system instructions, few-shot examples, and contextual information formatted for optimal model understanding.

Embedders and Retrievers form the foundation of RAG systems. Embedders convert text to dense vectors, while Retrievers perform similarity searches across your knowledge base, augmenting the model's input with relevant context.

Initial Setup: Integrating with Gemini 2.5 Pro and Flash

Getting Genkit running with Gemini requires minimal boilerplate:

# Requires Node.js 18+
npm init -y
npm install firebase-genkit @genkit-ai/gemini

Core initialization:

// genkit.ts
import { genkit } from 'genkit';
import { googleAI } from '@genkit-ai/googleai';
 
// Keep model IDs in one place so they can be swapped via environment
export const MODELS = {
  pro:   googleAI.model(process.env.GEMINI_PRO_MODEL   ?? 'gemini-2.5-pro'),
  flash: googleAI.model(process.env.GEMINI_FLASH_MODEL ?? 'gemini-2.5-flash'),
} as const;
 
const ai = genkit({
  plugins: [googleAI({ apiKey: process.env.GEMINI_API_KEY })],
  model: MODELS.pro,  // Default model for all operations
});
 
export default ai;

Keep Model IDs in One Place

I started out importing the model constants the plugin exports directly into every Flow. It works, but swapping models then means editing one import line per Flow. Once I passed twenty Flows, more of my time went into checking "is this the one Flow still pinned to the old model?" than into writing the Flows.

Now everything funnels through a single MODELS object, with the actual IDs coming from environment variables. Pointing staging at a newer model no longer requires a code change, and when it comes time to recompute costs — the section further down — I can see which Flow used which ID by reading one file.

Every code sample below assumes this MODELS object is imported.

Configuration best practices:

Always externalize API keys via environment variables. In production, use Google Cloud Secret Manager. For local development, use a .env.local file. Never hardcode credentials or use real key formats like AIzaSy.... Instead, use placeholder values like YOUR_GEMINI_API_KEY when documenting examples.

// Multi-environment configuration
const getApiKey = () => {
  if (process.env.ENVIRONMENT === 'production') {
    return process.env.GEMINI_API_KEY; // From Secret Manager
  }
  return process.env.LOCAL_GEMINI_KEY; // From .env.local
};
 
if (!getApiKey()) {
  throw new Error('GEMINI_API_KEY not configured');
}

The split is straightforward on paper: Pro for reasoning depth, Flash for latency and unit price.

What does not hold is the assumption that this relationship survives a generation change. As the numbers later in this article show, 3.x-series Flash models are priced well above 2.5-series Flash. If your code carries the assumption "anything called Flash is cheap," the surprise arrives on the invoice the month after you upgrade. Treat the model name as a signal about capability, not about price.

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦One month of real cost, latency, and p95 numbers from a Gemini 2.5 Flash review-summarization Flow running on a single indie iOS/Android app

✦Seven gotchas the official docs do not mention (35–45s cold starts, concurrency defaulting to 1, double-counted runFlow traces, Secret Manager billing, Flow rename breaking dashboards, PII in traces, streamCallback back-pressure)

✦Cloud Functions vs. Cloud Run decision matrix, plus a small pricing module that lets you re-derive monthly cost after the model lineup turns over

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Core Concepts: Building Flows, Tools, and Prompts

Flow Patterns: From Simple to Complex

Basic Text-to-Text Flow:

import { defineFlow } from 'genkit';
import { MODELS } from './genkit';
import { z } from 'zod';
 
export const summarizeArticle = defineFlow(
  {
    name: 'summarizeArticle',
    inputSchema: z.object({
      text: z.string().describe('Article text to summarize'),
      maxLength: z.number().default(200).describe('Maximum summary length')
    }),
    outputSchema: z.string()
  },
  async (input) => {
    const response = await ai.generate({
      model: MODELS.pro,
      prompt: `Summarize the following text in ${input.maxLength} characters or less:\n\n${input.text}`,
      config: {
        temperature: 0.3,  // Lower temperature for factual summarization
        maxOutputTokens: 500
      }
    });
 
    return response.text();
  }
);

Streaming-Enabled Flow:

The ability to stream responses is critical for user-facing applications. Instead of waiting for the entire response, you can send chunks to the client as they arrive.

export const streamingSummarize = defineFlow(
  {
    name: 'streamingSummarize',
    inputSchema: z.object({ text: z.string() }),
    outputSchema: z.string(),
    streamSchema: z.string()  // Declares streaming support
  },
  async (input, streamCallback) => {
    const stream = await ai.generate({
      model: MODELS.pro,
      prompt: `Summarize this concisely: ${input.text}`,
      streaming: true
    });
 
    let fullText = '';
    for await (const chunk of stream) {
      const chunkText = chunk.text();
      fullText += chunkText;
 
      // Send to client in real-time
      streamCallback(chunkText);
    }
 
    return fullText;
  }
);

Defining and Invoking Tools

Tools are JSON Schema-defined actions. Gemini analyzes the tool definitions and automatically calls them as needed.

import { defineTool } from 'firebase-genkit';
 
const getWeather = defineTool(
  {
    name: 'getWeather',
    description: 'Fetch weather for a specified city',
    inputSchema: z.object({
      city: z.string().describe('City name')
    }),
    outputSchema: z.object({
      temperature: z.number(),
      condition: z.string(),
      humidity: z.number()
    })
  },
  async (input) => {
    const response = await fetch(
      `https://weather-api.example.com?city=${encodeURIComponent(input.city)}`
    );
    return response.json();
  }
);
 
const bookFlight = defineTool(
  {
    name: 'bookFlight',
    description: 'Book a flight with given parameters',
    inputSchema: z.object({
      departure: z.string(),
      arrival: z.string(),
      date: z.string(),
      passengerCount: z.number()
    }),
    outputSchema: z.object({
      confirmationNumber: z.string(),
      totalPrice: z.number()
    })
  },
  async (input) => {
    const response = await fetch('https://flight-api.example.com/book', {
      method: 'POST',
      body: JSON.stringify(input)
    });
    return response.json();
  }
);

Integrating Tools into Flows:

export const tripPlannerAgent = defineFlow(
  {
    name: 'tripPlanner',
    inputSchema: z.object({
      destination: z.string(),
      departureDate: z.string(),
      returnDate: z.string()
    }),
    outputSchema: z.string()
  },
  async (input) => {
    const response = await ai.generate({
      model: MODELS.pro,
      tools: [getWeather, bookFlight],
      prompt: `
Plan a trip to ${input.destination} departing ${input.departureDate} and returning ${input.returnDate}.
- Check the weather forecast
- Find and book appropriate flights
- Provide a complete itinerary with recommendations
      `,
      maxIterations: 5  // Allow multiple tool calls
    });
 
    return response.text();
  }
);

RAG Implementation: Embedders and Retrievers

RAG (Retrieval Augmented Generation) dramatically improves factual accuracy by retrieving relevant documents before generation. Genkit provides first-class support.

Selecting and Configuring Embedders

import { defineEmbedder } from 'firebase-genkit';
import { embedding001 } from '@genkit-ai/gemini';
 
// Use Gemini's built-in embedder
const embedder = embedding001;
 
// Or define a custom embedder
const customEmbedder = defineEmbedder(
  {
    name: 'customEmbedder',
    configSchema: z.object({
      model: z.string(),
      apiKey: z.string()
    })
  },
  async (input, config) => {
    const response = await fetch('https://embedding-service.example.com/embed', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${config.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ texts: input, model: config.model })
    });
 
    const data = await response.json();
    return data.embeddings;
  }
);

Vector Store Integration with Pinecone

import { defineRetriever } from 'firebase-genkit';
import { Pinecone } from '@pinecone-database/pinecone';
 
const pc = new Pinecone({
  apiKey: process.env.PINECONE_API_KEY
});
 
const documentRetriever = defineRetriever(
  {
    name: 'documentRetriever',
    configSchema: z.object({
      index: z.string(),
      namespace: z.string().optional(),
      topK: z.number().default(5)
    })
  },
  async (input, config) => {
    const index = pc.index(config.index);
 
    // Embed the query
    const queryEmbedding = await embedding001.embed(input);
 
    // Query the vector store
    const results = await index.query({
      vector: queryEmbedding,
      topK: config.topK,
      namespace: config.namespace,
      includeMetadata: true
    });
 
    // Transform to document format
    return results.matches.map(match => ({
      content: match.metadata.content,
      metadata: {
        source: match.metadata.source,
        relevance: match.score
      },
      score: match.score
    }));
  }
);

Complete RAG Flow

export const knowledgeBaseQA = defineFlow(
  {
    name: 'knowledgeBaseQA',
    inputSchema: z.object({
      question: z.string(),
      topK: z.number().default(3)
    }),
    outputSchema: z.object({
      answer: z.string(),
      sources: z.array(z.string())
    })
  },
  async (input) => {
    // Retrieve relevant documents
    const documents = await documentRetriever.retrieve(input.question, {
      index: 'knowledge-base',
      topK: input.topK
    });
 
    const sources = documents
      .map(doc => doc.metadata.source)
      .filter(source => source);
 
    // Build context
    const context = documents
      .map(doc => doc.content)
      .join('\n\n---\n\n');
 
    // Generate answer
    const response = await ai.generate({
      model: MODELS.pro,
      prompt: `
You are a helpful assistant. Answer the question based on the provided context.
If the context doesn't contain relevant information, say so clearly.
 
Context:
${context}
 
Question: ${input.question}
 
Provide a clear, accurate answer.
      `,
      config: {
        temperature: 0.5,
        maxOutputTokens: 1000
      }
    });
 
    return {
      answer: response.text(),
      sources
    };
  }
);

Agent Patterns: Evolution from Sequential to Autonomous

AI agents exhibit increasingly sophisticated behavior through several distinct patterns:

Pattern 1: Sequential Processing

Fixed-order execution of multiple Flows. Predictable but limited adaptability.

export const contentCreationWorkflow = defineFlow(
  {
    name: 'contentCreationWorkflow',
    inputSchema: z.object({ topic: z.string() }),
    outputSchema: z.string()
  },
  async (input) => {
    // Phase 1: Research
    const research = await runFlow(researchPhase, { topic: input.topic });
 
    // Phase 2: Outline
    const outline = await runFlow(outlinePhase, { research });
 
    // Phase 3: Writing
    const article = await runFlow(writingPhase, { outline });
 
    // Phase 4: Refinement
    const refined = await runFlow(refinementPhase, { article });
 
    return refined;
  }
);

Pattern 2: Tool Calling (Autonomous Selection)

Gemini automatically selects and invokes appropriate Tools based on the task.

export const autonomousAssistant = defineFlow(
  {
    name: 'autonomousAssistant',
    inputSchema: z.object({
      request: z.string(),
      context: z.string().optional()
    }),
    outputSchema: z.string()
  },
  async (input) => {
    const response = await ai.generate({
      model: MODELS.pro,
      tools: [
        getWeather,
        bookFlight,
        checkHotelAvailability,
        getLocalAttractions,
        makeReservation
      ],
      prompt: `
User request: ${input.request}
${input.context ? `Context: ${input.context}` : ''}
 
Use available tools to fulfill the request comprehensively. Call multiple tools as needed.
      `,
      maxIterations: 10,
      config: {
        temperature: 0.7
      }
    });
 
    return response.text();
  }
);

Pattern 3: Iterative Refinement

The agent evaluates its own output and improves it through feedback loops.

export const qualityRefinedFlow = defineFlow(
  {
    name: 'qualityRefined',
    inputSchema: z.object({
      topic: z.string(),
      targetQuality: z.number().default(0.85)
    }),
    outputSchema: z.string()
  },
  async (input) => {
    let content = '';
    let qualityScore = 0;
    let iterations = 0;
    const maxIterations = 3;
 
    while (qualityScore < input.targetQuality && iterations < maxIterations) {
      // Generate content
      const generated = await ai.generate({
        model: MODELS.pro,
        prompt: `Write a comprehensive article about ${input.topic}.`
      }).then(r => r.text());
 
      // Evaluate quality
      const evaluation = await ai.generate({
        model: MODELS.pro,
        prompt: `
Rate the following article on a scale of 0 to 1 for completeness, accuracy, and clarity:
${generated}
 
Respond with JSON: {"score": 0.XX, "feedback": "..."}
        `,
        responseSchema: z.object({
          score: z.number().min(0).max(1),
          feedback: z.string()
        })
      });
 
      qualityScore = (evaluation as any).score;
 
      if (qualityScore >= input.targetQuality) {
        content = generated;
      } else {
        // Refine based on feedback
        content = await ai.generate({
          model: MODELS.pro,
          prompt: `
Improve this article based on the feedback. Make it more complete, accurate, and clear:
 
Feedback: ${(evaluation as any).feedback}
 
Article:
${generated}
        `
        }).then(r => r.text());
      }
 
      iterations++;
    }
 
    return content;
  }
);

Pattern 4: Fully Autonomous Systems

The agent maintains state, evaluates progress, and dynamically decides next actions.

export const fullyAutonomousAgent = defineFlow(
  {
    name: 'fullyAutonomous',
    inputSchema: z.object({
      goal: z.string(),
      maxSteps: z.number().default(10)
    }),
    outputSchema: z.object({
      result: z.string(),
      stepsTaken: z.number(),
      success: z.boolean()
    })
  },
  async (input) => {
    const executionLog = [];
    let currentStep = 0;
 
    while (currentStep < input.maxSteps) {
      // Ask agent what to do next
      const actionResponse = await ai.generate({
        model: MODELS.pro,
        tools: [
          searchInternet,
          queryDatabase,
          executeCode,
          delegateSubgoal
        ],
        prompt: `
Goal: ${input.goal}
 
Progress so far:
${executionLog.map(log => `- ${log}`).join('\n')}
 
What is your next action? If the goal is complete, respond with: GOAL_ACHIEVED
        `,
        maxIterations: 1
      });
 
      const action = actionResponse.text();
      executionLog.push(action);
 
      if (action.includes('GOAL_ACHIEVED')) {
        return {
          result: executionLog.join('\n'),
          stepsTaken: currentStep,
          success: true
        };
      }
 
      currentStep++;
    }
 
    return {
      result: executionLog.join('\n'),
      stepsTaken: currentStep,
      success: false
    };
  }
);

MCP Integration: Extending Agent Capabilities

The Model Context Protocol allows Gemini to interact with local resources—files, databases, APIs—through a standardized interface.

import { MCPClient } from '@modelcontextprotocol/sdk-js';
 
const mcpTools = defineModel(
  {
    name: 'mcpLocalResources',
    description: 'Access local files, databases, and services via MCP'
  },
  async (input: { toolName: string; params: Record<string, any> }) => {
    const client = new MCPClient({
      host: 'localhost',
      port: 3000
    });
 
    const response = await client.call(input.toolName, input.params);
    return response;
  }
);
 
export const codeAnalysisAgent = defineFlow(
  {
    name: 'codeAnalysis',
    inputSchema: z.object({ filePath: z.string() }),
    outputSchema: z.string()
  },
  async (input) => {
    const response = await ai.generate({
      model: MODELS.pro,
      tools: [mcpTools],
      prompt: `
Analyze the code in ${input.filePath}:
- Identify security vulnerabilities
- Suggest performance improvements
- Check for code style issues
- Propose refactoring opportunities
      `
    });
 
    return response.text();
  }
);

Deployment: Cloud Functions and Cloud Run

Cloud Functions: Small, Stateless Operations

Cloud Functions suits short-lived Flows that respond to HTTP requests.

// functions/src/index.ts
import * as functions from 'firebase-functions';
import { runFlow } from 'firebase-genkit';
import { summarizeArticle } from './flows';
 
export const summarize = functions.https.onCall(async (data, context) => {
  // Verify authentication
  if (!context.auth) {
    throw new functions.https.HttpsError(
      'unauthenticated',
      'You must be authenticated'
    );
  }
 
  try {
    const result = await runFlow(summarizeArticle, {
      text: data.text,
      maxLength: data.maxLength || 200
    });
 
    return { success: true, summary: result };
  } catch (error) {
    throw new functions.https.HttpsError(
      'internal',
      `Processing failed: ${error.message}`
    );
  }
});

Cold start mitigation:

// Warm up function every 5 minutes
export const warmUpFunction = functions.pubsub
  .schedule('every 5 minutes')
  .onRun(async () => {
    try {
      await ai.generate({
        model: MODELS.pro,
        prompt: 'warmup'
      });
      console.log('Function warmed');
    } catch (error) {
      console.error('Warmup failed:', error);
    }
  });

Cloud Run: Complex Workflows and Streaming

Cloud Run accommodates long-running processes and Server-Sent Events for streaming responses.

// Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 8080
CMD ["node", "server.js"]

// server.ts - Express application
import express from 'express';
import { runFlow } from 'firebase-genkit';
import { tripPlannerAgent } from './flows';
 
const app = express();
app.use(express.json());
 
// Streaming response endpoint
app.post('/api/plan-trip', async (req, res) => {
  const { destination, departureDate, returnDate } = req.body;
 
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');
 
  try {
    const chunks = [];
 
    await runFlow(
      tripPlannerAgent,
      { destination, departureDate, returnDate },
      {
        streamCallback: (chunk) => {
          res.write(`data: ${JSON.stringify({ chunk })}\n\n`);
          chunks.push(chunk);
        }
      }
    );
 
    res.write(`data: ${JSON.stringify({ done: true })}\n\n`);
    res.end();
  } catch (error) {
    res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
    res.end();
  }
});
 
const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
  console.log(`Server listening on port ${PORT}`);
});

Deploy to Cloud Run:

gcloud run deploy genkit-agent \
  --source . \
  --platform managed \
  --region us-central1 \
  --set-env-vars GOOGLE_API_KEY=YOUR_GEMINI_API_KEY \
  --allow-unauthenticated  # Remove for production

Security: Authentication, Authorization, and Secret Management

Authorization Policies

import * as functions from 'firebase-functions';
import * as admin from 'firebase-admin';
 
admin.initializeApp();
 
export const premiumOnlyFlow = functions.https.onCall(async (data, context) => {
  // Verify user is authenticated
  if (!context.auth) {
    throw new functions.https.HttpsError('unauthenticated', 'Login required');
  }
 
  // Check premium status in Firestore
  const userDoc = await admin.firestore()
    .collection('users')
    .doc(context.auth.uid)
    .get();
 
  if (!userDoc.exists || !userDoc.data()?.isPremium) {
    throw new functions.https.HttpsError(
      'permission-denied',
      'Premium subscription required'
    );
  }
 
  return await runFlow(expensiveComputationFlow, data);
});

Secret Manager Integration

import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
 
const secretManager = new SecretManagerServiceClient();
 
async function getSecret(secretName: string): Promise<string> {
  const projectId = process.env.GCP_PROJECT_ID;
  const name = `projects/${projectId}/secrets/${secretName}/versions/latest`;
 
  const [version] = await secretManager.accessSecretVersion({ name });
  const secretValue = version.payload.data.toString('utf8');
 
  return secretValue;
}
 
// Initialize Genkit with retrieved API key
const apiKey = await getSecret('gemini-api-key');
const ai = genkit({
  plugins: [googleAI({ apiKey })]
});

App Check for API Protection

import * as appCheck from 'firebase-functions/v2/https';
 
export const appCheckProtectedFlow = appCheck.onCall(
  { region: 'us-central1', cors: true },
  async (request) => {
    // Token is automatically validated by App Check
    return await runFlow(sensitiveFlow, request.data);
  }
);

Performance Optimization

Leveraging Cloud Functions Concurrency

# firebase.json
{
  "functions": {
    "runtime": "nodejs18",
    "concurrency": 100
  }
}

// Parallel Flow execution
export const parallelAnalysis = defineFlow(
  {
    name: 'parallelAnalysis',
    inputSchema: z.object({ documents: z.array(z.string()) }),
    outputSchema: z.array(z.string())
  },
  async (input) => {
    const analyses = await Promise.all(
      input.documents.map(doc =>
        runFlow(analyzeDocument, { content: doc })
      )
    );
 
    return analyses;
  }
);

Flow Grouping for Resource Efficiency

export const aiOperations = functions
  .runWith({
    memory: '2GB',
    timeoutSeconds: 300,
    concurrency: 50
  })
  .https.onCall(async (data, context) => {
    const { flowName, payload } = data;
 
    switch (flowName) {
      case 'summarize':
        return await runFlow(summarizeArticle, payload);
      case 'generate':
        return await runFlow(generateContent, payload);
      case 'translate':
        return await runFlow(translateContent, payload);
      default:
        throw new Error(`Unknown flow: ${flowName}`);
    }
  });

Intelligent Caching

import * as admin from 'firebase-admin';
 
export const cachedQA = defineFlow(
  {
    name: 'cachedQA',
    inputSchema: z.object({ question: z.string() })
  },
  async (input) => {
    const db = admin.firestore();
    const cacheKey = Buffer.from(input.question).toString('base64');
 
    // Check cache
    const cached = await db.collection('qa_cache').doc(cacheKey).get();
    if (cached.exists && !isCacheExpired(cached.data())) {
      return cached.data().answer;
    }
 
    // Cache miss: compute answer
    const answer = await runFlow(ragQA, input);
 
    // Store in cache with TTL
    await db.collection('qa_cache').doc(cacheKey).set({
      answer,
      timestamp: admin.firestore.FieldValue.serverTimestamp(),
      ttl: 86400  // 24 hours
    });
 
    return answer;
  }
);
 
function isCacheExpired(data: any): boolean {
  const now = Date.now();
  const created = data.timestamp.toMillis();
  const age = (now - created) / 1000;
  return age > data.ttl;
}

Production Observability

Automatic Tracing

Genkit captures all API calls and execution metrics automatically:

import { getLogger } from 'firebase-functions/logger';
 
export const observableFlow = defineFlow(
  {
    name: 'observableFlow',
    inputSchema: z.object({ query: z.string() })
  },
  async (input) => {
    const logger = getLogger();
 
    logger.info('Flow started', {
      query: input.query,
      timestamp: new Date().toISOString()
    });
 
    const result = await ai.generate({
      model: MODELS.pro,
      prompt: input.query
    });
 
    logger.info('Flow completed', {
      tokens: result.usage,
      latency: result.latency
    });
 
    return result.text();
  }
);

Cloud Logging

import * as logging from '@google-cloud/logging';
 
const log = logging.log('genkit-production');
 
export const loggedFlow = defineFlow(
  {
    name: 'loggedFlow',
    inputSchema: z.object({ data: z.any() })
  },
  async (input) => {
    log.write(log.entry({
      severity: 'INFO',
      message: 'Flow execution',
      data: input
    }));
 
    const result = await runFlow(processData, input);
 
    log.write(log.entry({
      severity: 'INFO',
      message: 'Flow completed',
      result
    }));
 
    return result;
  }
);

Cost Optimization Strategies

Model Selection by Use Case

Task Type	Recommended Model	Rationale
Summarization, Classification	Gemini 2.5 Flash	Fast, cost-effective
Content Generation	Gemini 2.5 Pro	Balanced quality and speed
Complex Reasoning	Gemini 2.5 Pro	Requires deep analysis

export const smartModelSelection = defineFlow(
  {
    name: 'smartModelSelection',
    inputSchema: z.object({
      taskType: z.enum(['summarize', 'generate', 'reason']),
      content: z.string()
    })
  },
  async (input) => {
    const model = {
      'summarize': MODELS.flash,
      'generate': MODELS.pro,
      'reason': MODELS.pro
    }[input.taskType];
 
    return await ai.generate({
      model,
      prompt: input.content
    }).then(r => r.text());
  }
);

Batch Processing

Process multiple items in a single API call when possible:

export const batchProcessing = defineFlow(
  {
    name: 'batchProcessing',
    inputSchema: z.object({
      items: z.array(z.string())
    })
  },
  async (input) => {
    const prompt = `Process the following ${input.items.length} items:
 
${input.items.map((item, i) => `${i + 1}. ${item}`).join('\n')}
 
Provide analysis for each.`;
 
    return await ai.generate({
      model: MODELS.pro,
      prompt
    }).then(r => r.text());
  }
);

Real-World Implementation: AI-Powered Customer Support

A complete system that handles support tickets with autonomous AI assistance:

// Fetch support ticket details
const fetchSupportTicket = defineTool(
  {
    name: 'fetchSupportTicket',
    description: 'Retrieve support ticket by ID',
    inputSchema: z.object({ ticketId: z.string() }),
    outputSchema: z.object({
      id: z.string(),
      customerId: z.string(),
      issue: z.string(),
      status: z.string(),
      priority: z.enum(['low', 'medium', 'high'])
    })
  },
  async (input) => {
    const response = await fetch(
      `https://support-api.example.com/tickets/${input.ticketId}`
    );
    return response.json();
  }
);
 
// Update ticket with AI response
const respondToTicket = defineTool(
  {
    name: 'respondToTicket',
    description: 'Send response to support ticket',
    inputSchema: z.object({
      ticketId: z.string(),
      response: z.string(),
      status: z.enum(['open', 'waiting', 'resolved'])
    }),
    outputSchema: z.object({ success: z.boolean() })
  },
  async (input) => {
    const response = await fetch(
      `https://support-api.example.com/tickets/${input.ticketId}/respond`,
      {
        method: 'POST',
        body: JSON.stringify({
          message: input.response,
          status: input.status
        })
      }
    );
    return { success: response.ok };
  }
);
 
// Main support agent
export const supportAgent = defineFlow(
  {
    name: 'supportAgent',
    inputSchema: z.object({ ticketId: z.string() })
  },
  async (input) => {
    // Retrieve ticket
    const ticket = await runFlow(
      defineFlow({ name: 'fetch' }, async () =>
        await fetchSupportTicket.invoke({ ticketId: input.ticketId })
      ),
      {}
    );
 
    // Generate response
    const response = await ai.generate({
      model: MODELS.pro,
      tools: [respondToTicket],
      prompt: `
Support Ticket #${ticket.id}
Priority: ${ticket.priority}
Issue: ${ticket.issue}
 
Provide a helpful response. If the issue can be resolved, mark as resolved.
If more information is needed, mark as waiting.
      `,
      maxIterations: 2
    });
 
    return response.text();
  }
);

Seven Gotchas the Official Docs Do Not Mention

The following are issues I actually hit while running Firebase Genkit on my own back end for a month. They are listed roughly in the order you are likely to step on them, not by severity.

1. Cold Start with the First Gemini Call Lands at 35–45 Seconds

On Cloud Functions Gen2 with Genkit and Gemini 2.5 Pro, my measured cold-start-to-first-token latency was 35–45 seconds. The breakdown was roughly 8–12 s for the container, 4–6 s for Genkit initialization (the googleAI plugin resolution inside genkit({...})), and 20–25 s for the first generate call against Pro.

Switching the model to Flash brought the response portion down to 8–12 s, but the cold start envelope still sat at 20–28 s. Because my apps live on AdMob revenue and any user-facing delay risks impressions, I stopped putting Gemini on user-tap code paths and split the workload into background batch summarization plus a Cloud Run container with minInstances: 1 for anything synchronous.

# firebase.json — bigger memory + a single warm instance to absorb cold starts
{
  "functions": {
    "runtime": "nodejs18",
    "memory": "1GiB",
    "concurrency": 80,
    "minInstances": 1
  }
}

minInstances: 1 adds a few dollars a month in my setup, but the long tail of cold-start latency essentially disappears. For an AdMob-monetized app where higher eCPM windows are the wrong place to make users wait, this paid for itself.

2. The Concurrency Default Stays at 1 Even on Gen2

The Cloud Functions Gen2 docs list concurrency limits up to 1000, but on multiple deploys with default settings I caught my containers running with concurrency 1. Because Gemini calls spend almost all their wall time waiting on I/O, concurrency 1 means a burst of 10 simultaneous requests spins up 10 containers — and you eat the cold-start tail and the startup cost for each one.

I now set concurrency: 50 as a floor for any Gemini-calling function, and 80 for Flash-heavy paths. Functions that use Pro stay around 30 because they push memory harder.

3. `runFlow` Nesting Double-Counts Tokens in Traces

Genkit's tracing is excellent, but if you call runFlow(childFlow, ...) inside runFlow(parentFlow, ...), the Cloud Logging trace export attributes token usage to both flows. At one month-end I found my Genkit trace summary was about 1.8× the actual Cloud Billing line item for the Generative Language API, which was confusing for ten minutes.

The fix is operational, not technical: treat Cloud Billing's generativelanguage.googleapis.com line as the source of truth for cost, and keep Genkit traces strictly for debugging — do not surface them on a dashboard alongside billing numbers.

4. Secret Manager `accessSecretVersion` Adds Up If You Call It Per Cold Start

accessSecretVersion is cheap at roughly $0.03 per 10,000 calls, but if every cold start hits it, the cost is small but the latency adds another 150–300 ms on top of an already painful cold start. I now grab the API key once at module load and cache it in module scope. Warm invocations skip the call entirely.

let cachedApiKey: string | null = null;
async function getCachedSecret(name: string): Promise<string> {
  if (cachedApiKey) return cachedApiKey;
  const [version] = await secretManager.accessSecretVersion({ name });
  cachedApiKey = version.payload.data.toString("utf8");
  return cachedApiKey;
}

5. Flow Names Are Plain Strings — Renaming Silently Breaks Your Dashboards

defineFlow({ name: 'summarizeArticle', ... }) writes that exact string straight into Cloud Logging labels. I once renamed a Flow to summarizeArticleV2 during a refactor, and it took me three days to notice that my monitoring dashboards and Slack alerts were still filtering on the V1 name and showing nothing.

When you rename, rewrite your queries to a wildcard like name=~"summarizeArticle.*" first, then migrate. The order matters.

6. Traces Capture PII — Add a Redactor Before Shipping

Genkit's auto-tracing writes Flow inputs straight into Cloud Logging. The review-summarization Flow I was running occasionally received user text containing email addresses or phone numbers, and I only noticed after the fact when scrolling through logs.

Wrap the Flow entry point with a redactor for anything that looks like PII. My version is intentionally crude — email, phone, credit-card-sized digit sequences — and runs before the input ever reaches defineFlow.

const REDACT_PATTERNS = [
  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
  /\b0\d{1,3}-?\d{2,4}-?\d{3,4}\b/g,
  /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,
];
function redact(text: string): string {
  return REDACT_PATTERNS.reduce(
    (acc, pat) => acc.replace(pat, "[REDACTED]"),
    text
  );
}

For any app that funnels user-generated text into Gemini, skipping this means PII sits in Cloud Logging for the default 30-day retention window.

7. `streamCallback` Is Synchronous — Heavy Work Inside It Causes Back-Pressure

The streamCallback you pass to a streaming Flow is invoked synchronously every time Gemini delivers a chunk. If you naively put a database write or an outbound API call in there, the time that takes blocks the next chunk from being consumed, and your end-to-end latency roughly doubles or triples.

Keep streamCallback to a queue.push(chunk)-style operation and offload the actual work to a separate worker or setImmediate boundary.

const bufferQueue: string[] = [];
let flushTimer: NodeJS.Timeout | null = null;
 
const streamCallback = (chunk: string) => {
  bufferQueue.push(chunk);
  if (!flushTimer) {
    flushTimer = setImmediate(() => {
      const batch = bufferQueue.splice(0);
      // Heavy work (DB writes etc.) happens here, off the streaming path
      persistChunks(batch);
      flushTimer = null;
    });
  }
};

What It Actually Costs and How Fast It Actually Is

These numbers come from a single Flow I ran in production for a month: a review summarizer that processes roughly 12,000 reviews per month for one of my wallpaper apps.

Per-Model Cost and Latency (April 2026 measurements)

Model	Avg Input / Output Tokens	Avg Latency	p95 Latency	Cost per Request	Monthly Cost (12,000 req)
Gemini 2.5 Pro	1,800 / 250	4.2 s	11.8 s	$0.018	~$216
Gemini 2.5 Flash	1,800 / 250	1.1 s	3.4 s	$0.0014	~$17
Gemini 2.0 Flash	1,800 / 250	0.9 s	2.7 s	$0.0009	~$11

For a task like "clean up and summarize Japanese review text," 2.5 Flash gave me output quality I was happy with. Cost dropped roughly 12.7× and latency 4× compared with Pro. I eventually settled on Flash and run the whole pipeline for about $17 a month.

End-to-End Latency Including Cold Start (Cloud Functions Gen2)

State	Pro	Flash
Warm (immediately after a call)	4.2 s	1.1 s
Cool (after 5+ minutes idle)	28 s	20 s
Cold (first invocation)	42 s	24 s
Cold + minInstances=1	5.0 s	1.4 s

Adding minInstances: 1 cost me about $4 a month for this configuration. I do not pay it for the asynchronous review summarizer, but I do pay it for the FAQ bot users hit directly.

Cache Hit Rate Compression

// Effective cost after Firestore cache for identical review bodies
const CACHE_HIT_RATE = 0.18;  // ~18% in my data
const ORIGINAL_COST_PER_MONTH = 17;  // Flash baseline
const EFFECTIVE_COST = ORIGINAL_COST_PER_MONTH * (1 - CACHE_HIT_RATE);
// → ~$14/month (another $3 off)

Review summarization has a low cache hit rate because few reviews are identical. A FAQ bot, on the other hand, sees cache hit rates of 50–65% in my measurements, dropping a $17/month workload to roughly $7.

Protecting Measurements from Model Generation Churn

The table above was measured in April 2026. The Flash lineup has turned over since, so reading that row as "Flash costs $17 a month" will now put you in the wrong place.

At the time, 2.5 Flash worked out to $0.0014 per request, roughly $17 a month at 12,000 requests. As of July 2026, 3.6 Flash is published at $1.50 per 1M input tokens and $7.50 per 1M output tokens. Push the exact same token counts through those numbers:

Line item	Monthly tokens	Unit price (per 1M)	Monthly
Input (1,800 × 12,000 req)	21.6M	$1.50	$32.40
Output (250 × 12,000 req)	3.0M	$7.50	$22.50
Total	—	—	~$54.9

Same workload, same token counts, same word in the model name. The bill goes from $17 to about $55 — more than triple.

3.6 Flash is documented as producing roughly 17% fewer output tokens than 3.5 Flash. Even crediting that fully (250 → 208 output tokens), the output side only falls to $18.7 and the total to about $51. The efficiency gain is real; it just does not close a 5× unit-price gap.

That is what makes 3.5 Flash-Lite interesting, listed at $0.3 per 1M input tokens. Summarizing review text is a task where volume dominates difficulty — it is tidying, not reasoning. If moving up a generation is not the goal in itself, dropping to the Lite tier is the more honest fit.

Measure Tokens, Treat Prices as Variables

The lesson I took from this: the things worth measuring are token counts and p95 latency; dollar amounts should always be recomputable. Bake a dollar figure into a document and it goes stale the moment the model changes — and nothing about the document shows that it has.

So I store measurements as tokens per request, and read unit prices from a separate file.

// pricing.ts — prices live alone here, updated from the official pricing page
export const PRICE_PER_1M = {
  "gemini-2.5-flash":      { input: 0.30, output: 2.50 },
  "gemini-3.6-flash":      { input: 1.50, output: 7.50 },
  "gemini-3.5-flash-lite": { input: 0.30, output: null },  // output price unverified
} as const;
 
type Measured = {
  inputTokens: number;      // measured, per request
  outputTokens: number;
  requestsPerMonth: number;
};
 
export function monthlyCost(modelId: keyof typeof PRICE_PER_1M, m: Measured): number {
  const p = PRICE_PER_1M[modelId];
  if (p.output === null) {
    // Treating an unverified price as zero makes estimates quietly too small
    throw new Error(`output price for ${modelId} is unverified`);
  }
  const inputM  = (m.inputTokens  * m.requestsPerMonth) / 1_000_000;
  const outputM = (m.outputTokens * m.requestsPerMonth) / 1_000_000;
  return inputM * p.input + outputM * p.output;
}
 
// Re-read April 2026 token measurements against current prices
const measured: Measured = { inputTokens: 1800, outputTokens: 250, requestsPerMonth: 12000 };
 
monthlyCost("gemini-2.5-flash", measured);  // → ~$14.0
monthlyCost("gemini-3.6-flash", measured);  // → ~$54.9

The $14.0 figure for gemini-2.5-flash does not match the $17 I actually paid, and the gap is retries. A theoretical calculation counts only successful calls; it misses the requests that came back rate-limited and got resent, and the responses that failed schema validation and were re-issued. In my case that overhead ran about 20%, so I now budget against the theoretical number multiplied by 1.2.

Throwing on output: null rather than swallowing it is deliberate too. I nearly talked myself into "Lite has the same input price, so the total should hold" before checking the output side — unverified numbers should not pass silently.

Prices change. The figures above were taken from the Gemini API pricing page at the time of writing, so please confirm the current values yourself.

Where to Put Genkit When Ad Revenue Pays the Bills

Closing with what I have actually deployed: the design rules I follow for indie apps where a one-second latency change can move the AdMob eCPM enough to matter.

Pattern A: Keep Gemini Out of the User-Tap Path

In my wallpaper apps, the home screen, search, and download flows do not call Gemini at all. Those screens have the highest AdMob impression density, and slowing them down hurts ad revenue directly.

The places I do use Gemini are explicit "Generate" buttons — name this wallpaper, write a description for this collection — where users have asked the app to think for a moment. Loading states are expected there, so even Pro is fine.

Pattern B: Run Genkit Flows During Off-Peak Batch Windows

Tag generation for new wallpapers, review summarization, SEO description rewriting — anything that does not need to block a user — runs in Cloud Scheduler batches in my local off-peak window (02:00–05:00 JST).

// User-disconnected batch fired by Cloud Scheduler
export const overnightTagGeneration = functions.pubsub
  .schedule("0 3 * * *")
  .timeZone("Asia/Tokyo")
  .onRun(async () => {
    const newWallpapers = await fetchNewWallpapersWithoutTags();
    for (const wallpaper of newWallpapers) {
      await runFlow(tagGenerationFlow, { wallpaperId: wallpaper.id });
    }
  });

Cold starts in this window do not matter, and the Gemini rate limits are far easier to live with. I push roughly 80,000 auto-tag operations per month through this path on Flash, for about $25/month.

Pattern C: FAQ / Support Bots — Flash + Aggressive Caching, Temperature Locked Down

For support FAQ search, where users will accept a few seconds, I stay on 2.5 Flash and put a 24-hour Firestore cache in front. Identical questions return from cache; new questions hit Flash.

// FAQ bot — low temperature, heavy caching
const faqResponse = await ai.generate({
  model: MODELS.flash,
  prompt: faqPrompt,
  config: {
    temperature: 0.2,  // Stability over personality
    maxOutputTokens: 400,
  }
});

I keep temperature: 0.2 because creative FAQ answers actually increase support load. When I ran a period at temperature: 0.7, several users wrote in based on Gemini's invented usage instructions and we ended up doing manual cleanup — so this is one knob I deliberately pin low.

Cloud Functions vs. Cloud Run — A Working Decision Matrix

Workload	Recommendation	Why
User-tap, must respond fast	Cloud Run + minInstances=1 + Flash	Cold start is unacceptable
Off-peak batch, high volume	Cloud Functions Gen2 + tuned concurrency	Bursty startup, low fixed cost
Streaming required	Cloud Run (Functions SSE tops out at 60 s)	Functions SSE will time out
Long-running, infrequent	Cloud Functions, minimum config	Per-invocation cost beats always-on
Long-running, high volume	Cloud Run + high concurrency	One container multiplexes many requests

My current production layout is Cloud Functions Gen2 for review summarization and tag generation, plus a single Cloud Run service for the FAQ bot. For an AdMob-funded business where daily revenue swings, keeping the fixed minInstances footprint tight has been worth the discipline.

Wrapping up and Next Steps

After a month of running Firebase Genkit in production, the honest summary is that operations got quieter. The token-budget checks, retry loops, and structured logging that used to be scattered across my Cloud Functions now collapse into Flow, Tool, and tracing — and code reviews have one fewer thing to argue about.

But as this article has tried to show, you only get there if you walk around the seven undocumented potholes: cold-start tails, the silent concurrency=1 default, double-counted runFlow traces, Secret Manager call patterns, dashboards that depend on Flow names, PII in trace logs, and the synchronous streamCallback. Miss any of them and your costs or latency drift to roughly 2–3× of what you planned.

One thing that did not work, for the record: I built automatic model routing based on input length, and then removed it. The premise — longer input means a harder task — simply does not hold for review text. Short one-liners were the ones that tripped the model up, because sarcasm and idiom live there. Routing is now explicit, by task type (summarize, generate, reason). The judgments that look most automatable are the ones where I should have verified the correlation first.

If you are adding Genkit now, I would start with a non-user-facing batch use case on Flash, measure cost and latency for a few weeks, and only then promote a piece of it to a warm Cloud Run service. That is the path I followed, and it kept the AdMob math intact while I learned what the framework actually does in production.

The next practical step is to look at your own work or app and find one task that a human repeats every day. Replace that single task with one defineFlow. Genkit's real value shows up in how cleanly that small thing can grow afterwards.

If you are wiring Gemini into your own indie back end, I hope these notes save you a few of the days I spent on the same questions. Thank you for reading.

Thank You for Reading

Gemini Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

✦Copy-paste ready implementation code
✦New advanced guides published daily
✦$5/mo or $10 for lifetime access

View Membership →