AI becomes far more useful when it can work with personal context while still keeping user data secure. That idea inspired me to build Gemini Reflection Journal, a secure, user-authenticated AI journaling application that combines personal reflection with generative AI.

The application allows users to sign in securely, write private journal entries, optionally record their mood, and receive thoughtful AI-powered reflections from Gemini. Entries are stored separately for each authenticated user, allowing reflection history and mood trends to remain available across sessions.

The project brings together Firebase Authentication, Cloud Firestore, the Gemini API, and Google Cloud Run to create a production-deployed AI application with authentication, persistent storage, and server-side AI integration.

In this article, I'll walk through what I built, how the different Google Cloud and Firebase services work together, and some of the features I added to turn the original concept into a more complete reflection experience.

#AccelerateAIwithCloudRun

What I Built:

Gemini Reflection Journal is a personal AI reflection workspace designed around three ideas: privacy, continuity, and useful AI-assisted reflection.

After signing in with Google, each user gets an isolated journaling space where they can create entries and continue multi-turn reflections with Gemini. Instead of generating a single response and forgetting it, the application preserves the conversation as part of the journal entry so users can return to their previous reflections.

I also extended the application with optional mood tracking. Users can select from Positive, Calm, Motivated, Neutral, Stressed, or Confused before submitting a reflection. These self-reported moods are stored with the journal entry and used as additional context for Gemini.

The Reflection History page brings everything together with saved entries, search, mood filters, mood badges, and a Recent Mood Insight section that summarizes the user's recently logged moods. These insights are intentionally presented as personal reflection trends rather than medical or diagnostic information.

Gemini Reflection Journal running as a deployed, authenticated AI application.

Architecture & Technology Stack:

Gemini Reflection Journal uses a secure full-stack architecture where authentication, user data, AI generation, and deployment each have a clearly defined role.

Firebase Authentication handles Google Sign-In and provides each authenticated user with a unique identity. This identity is used to keep journal data isolated between users.

Cloud Firestore provides persistent storage for journal entries, conversation turns, mood information, and reflection history. User data is organized under owner-specific paths so that each account accesses its own journal collection.

Gemini API powers the AI reflection experience. Journal content and optional mood context are sent through the application's server-side AI flow, allowing Gemini to generate relevant multi-turn reflections without exposing the Gemini API key in the browser.

Google Cloud Secret Manager is used to securely manage the Gemini API credential rather than embedding the secret directly into the application's public source code.

Google Cloud Run hosts the production application and provides the publicly accessible deployment. This brings the frontend, authenticated workflow, Firestore integration, and server-side Gemini functionality together in a scalable cloud environment.

Technology Stack:

• Frontend: React + TypeScript

• Authentication: Firebase Authentication with Google Sign-In

• Database: Cloud Firestore

• AI: Gemini API

• Secret Management: Google Cloud Secret Manager

• Deployment: Google Cloud Run

Architecture diagram:

User

↓

Google Sign-In

↓

Firebase Authentication

↓

Gemini Reflection Journal on Cloud Run

├──→ Cloud Firestore → Private journal history

|──→ Server-side Gemini API → AI-powered reflection

↑

Secret Manager

Secure Authentication & User Data Isolation:

Security and user privacy were important parts of the application architecture. Firebase Authentication provides Google Sign-In, allowing users to access the journal through their own authenticated account.

After authentication, each user's journal entries are stored in Cloud Firestore under a user-specific path:

users/{userId}/journals/{journalId}

This structure keeps journal data associated with its authenticated owner and prevents different users' reflection histories from being mixed together.

Firestore security rules complement this structure by restricting access based on the authenticated user's identity. As a result, journal entries, conversation history, and self-reported mood information remain associated with the correct account.

Authentication also persists across sessions, creating a smoother experience while maintaining the separation between users.

Authenticated reflection history with user-specific Firestore persistence and optional mood tracking.

Gemini-Powered Multi-Turn Reflection:

The core AI experience of Gemini Reflection Journal is powered by the Gemini API. Instead of treating journaling as a simple question-and-answer interaction, the application supports multi-turn reflection, allowing users to continue exploring the same thought through follow-up responses.

When a user submits a journal entry, the application sends the reflection to the server-side Gemini integration. Gemini generates a thoughtful response designed to help the user examine ideas, challenges, accomplishments, and possible next steps.

Optional mood information can also provide additional context. For example, a user may mark an entry as Motivated, Calm, or Confused before submitting it. The selected mood is validated against a fixed set of supported values before being included as reflection context.

The AI experience is intentionally designed for personal reflection rather than medical or clinical assessment. Mood information is treated as self-reported context, and the generated responses remain non-diagnostic.

Most importantly, the Gemini API key remains server-side. It is not embedded in the client application or committed to the public GitHub repository.

A Typical Reflection Flow

1. The user signs in using Google.

2. The user creates a new journal entry.

3. They optionally select a mood.

4. The reflection is submitted to the server.

5. Gemini generates an AI-assisted reflection.

6. The user can continue with follow-up messages.

7. The completed entry and conversation are persisted in Firestore.

8. The entry becomes available from Reflection History.

Gemini generating contextual, multi-turn reflection from an authenticated user's journal entry.

Beyond the Base App: Mood & Insight Tracker:

To extend the starter application beyond basic AI journaling, I built a lightweight Mood & Insight Tracker using Google AI Studio.

Before submitting a reflection, users can optionally choose from six self-reported moods: Positive, Calm, Motivated, Neutral, Stressed, or Confused. Mood selection remains completely optional, keeping the journaling experience simple.

The selected mood is validated before being processed, stored alongside the user's journal entry in Firestore, and supplied to Gemini as additional contextual information rather than as an instruction.

I also added a Recent Mood Insight section to Reflection History. It examines only the authenticated user's recent entries and identifies simple patterns such as their most frequently logged mood.

Users can also filter their history by mood, making it easier to revisit reflections written in a particular context.

This feature was deliberately designed to remain lightweight and non-diagnostic. It provides a way to observe self-reported reflection patterns without making psychological, medical, or predictive claims.

What the enhancement adds

• Optional mood selection during journaling

• Mood-aware Gemini reflection context

• Persistent mood information in Firestore

• Mood badges on saved reflections

• Mood-based history filtering

• Recent Mood Insight

• Strict per-user isolation of mood information

The custom Mood & Insight Tracker showing self-reported reflection trends from the user's private journal history.

Security-First Development:

A major goal of this project was to treat security as part of the architecture rather than something added after development.

Before building the application, I configured Google AI Studio Custom Instructions with security-focused development directives covering threat modeling, secure coding, authentication boundaries, Firestore data isolation, secret management, and security reviews.

The application follows several important security practices:

• Firebase Authentication establishes authenticated user identities through Google Sign-In.

• Firestore Security Rules restrict journal access to the authenticated owner using request.auth.uid == userId.

• Journal data follows the isolated path users/{userId}/journals/{journalId}.

• Google Cloud Secret Manager is used for sensitive Gemini API credentials.

• Gemini requests are handled through the server-side application layer, keeping the Gemini API key out of browser code.

• Mood inputs are validated against an allowlist before processing or persistence.

• User-generated content is treated as data rather than trusted application instructions.

• The public repository contains environment-variable placeholders rather than production secrets.

This security-first workflow helped turn the project from a functional AI prototype into a more production-oriented application.

Firestore ownership rule:

allow read, write:

if request.auth != null

&& request.auth.uid == userId;

This ensures an authenticated user can access journal documents only within their own user path.

Deploying to Google Cloud Run:

After testing the application in Google AI Studio, I published it as a production application using Google Cloud Run.

Cloud Run provides the production runtime for the application while connecting the different pieces of the architecture: the React interface, Firebase Authentication, Cloud Firestore persistence, and the server-side Gemini integration.

After deployment, I tested the complete production workflow rather than relying only on the development preview:

Google Sign-In → Journal Entry → Gemini Reflection → Firestore Persistence → Reflection History

I also verified that saved reflections remain available after signing out and signing back in, confirming that the production application is using persistent user-specific storage.

As part of the Cloud Run AI Challenge configuration, the deployed Cloud Run service was also labeled with:

dev-tutorial = cloud-run-ai-challenge

This completed the production deployment and challenge configuration for the application.

What I Learned:

Building Gemini Reflection Journal showed me that creating an AI application involves much more than connecting a model to an interface. Authentication boundaries, database security, secret management, persistent state, deployment, and production testing are equally important.

Google AI Studio helped accelerate development, while Firebase Authentication and Firestore provided identity and persistent user-isolated storage. Gemini provided the intelligence behind the reflection experience, and Cloud Run provided the production environment that brought everything together.

Extending the application with the Mood & Insight Tracker also gave me an opportunity to move beyond the starter specification while keeping the feature aligned with the application's original purpose.

The result is a working, publicly deployed AI application built around both useful AI interaction and secure application architecture.

Try the Project:

https://haseeb-reflection-vault.ai.studio

https://github.com/Syed-0507/gemini-reflection-journal

Built for the Cloud Run AI Challenge.

#AccelerateAIwithCloudRun #GoogleCloud #Gemini #Firebase #CloudRun #GoogleAIStudio #GenerativeAI

Generative AI becomes much more interesting when it moves beyond simple conversations and starts interacting with real data, tools, and applications.

As part of the Gen AI Academy APAC Edition, I had the opportunity to explore this through hands-on Google Cloud codelabs. Instead of only learning about AI agents conceptually, I built and deployed agents that could analyze datasets, interact with external tools, make data-driven recommendations, and perform actions after receiving user approval.

Throughout this journey, I worked with Google Cloud Run, Agent Development Kit (ADK), Gemma 4, Gemini, BigQuery, Model Context Protocol (MCP), Google Sheets, Python, and other Google Cloud services.

In this article, I'll share what I built, how the different components worked together, and some of the key things I learned while turning AI models into practical agents.

Deploying Gemma 4 on Google Cloud Run

One of the first major tasks was deploying a Gemma 4 model using vLLM on Google Cloud Run. This gave me hands-on experience with serving a large language model through cloud infrastructure rather than simply interacting with an existing AI interface.

The deployment involved configuring my Google Cloud project, setting up networking with Direct VPC Egress, configuring service account permissions, allocating GPU and memory resources, and deploying the vLLM container to Cloud Run.

Once deployed, the model was available through an OpenAI-compatible API. Since the Cloud Run service required authentication, I used a Google Cloud identity token when sending requests to the model.

To verify the deployment, I sent the model a simple question: “Why is the sky blue?” The model successfully generated a response, confirming that the complete inference pipeline was working.

Building a Data-Driven AI Agent with ADK and BigQuery MCP

After deploying the model, I moved from basic model inference to building an AI agent capable of working with real-world data. Using Google’s Agent Development Kit (ADK), I created a data agent that could interact with the NYC Citi Bike dataset stored in BigQuery. The agent was connected to BigQuery through the Model Context Protocol (MCP), allowing it to inspect available tables, understand their schemas, generate SQL queries, and analyze the results based on natural-language requests. I tested the agent with a practical business scenario: “We have budget for 3 coffee trucks. We want to find the best city bike stations to place our coffee trucks.” Instead of returning a generic recommendation, the agent analyzed historical Citi Bike trip activity and identified three of the busiest stations:

1. E 17 St & Broadway

2. Pershing Square North

3. W 21 St & 6 Ave. This demonstrated how an AI agent can combine natural-language reasoning with structured data analysis to produce useful, data-backed recommendations.

Building a Personal Coffee Shop AI Agent with Google Sheets

During the next codelab, I built a more action-oriented AI agent designed to help manage a coffee shop during a university graduation weekend. The agent used historical 2025 Point-of-Sale (POS) data stored in Google Sheets and compared it with the 2026 graduation schedule. Its goal was to identify demand spikes and recommend inventory and staffing adjustments for the upcoming event. Using Google ADK and Gemini, the agent could read spreadsheet data, analyze historical patterns, identify operational bottlenecks, and generate recommendations. One particularly interesting feature was Human-in-the-Loop approval. Instead of immediately modifying the spreadsheet, the agent first presented its recommendations and asked for permission. For example, the agent identified high-demand periods following graduation ceremonies and recommended actions such as:

1. Scheduling a Support Barista during major beverage-demand spikes.

2. Preparing additional staff for post-ceremony rush periods.

3. Pre-staging additional inventory such as alternative milk before predicted demand surges. Only after receiving my approval did the agent create a TODO-2026 sheet and write the approved tasks into it. This demonstrated an important concept in agentic AI: an AI system can analyze information and propose actions while still keeping the human in control of consequential changes.

Technologies I Worked With

Throughout the Gen AI Academy APAC journey, I worked with several technologies that together form a modern stack for building and deploying AI agents.

• Google Cloud Run for deploying and hosting AI applications.

• Google Agent Development Kit (ADK) for creating and orchestrating AI agents.

• Gemma 4 and Gemini as the language models powering the applications.

• BigQuery for querying and analyzing structured datasets.

• Model Context Protocol (MCP) for enabling the agent to interact with external data tools.

• Google Sheets API for reading and updating spreadsheet data programmatically.

• Python for implementing agent logic, tools, data processing, and backend functionality.

• FastAPI and Uvicorn for serving the Coffee Shop Agent as a web application.

• Google Cloud IAM and Service Accounts for authentication and controlled access to cloud resources.

What I Learned

The biggest takeaway from these codelabs was understanding that building an AI agent involves much more than simply sending prompts to a language model.

I learned how an agent can be connected to real data sources, equipped with tools, deployed as a cloud application, and designed to perform actions based on its reasoning.

Working with BigQuery and MCP showed me how natural-language requests can be translated into useful data analysis. The Coffee Shop Agent demonstrated another important concept: Human-in-the-Loop AI, where the agent recommends an action but waits for explicit user approval before modifying external data.

I also gained practical experience with cloud deployment, APIs, service accounts, IAM permissions, environment variables, troubleshooting, and integrating multiple Google Cloud services into a working application.

Most importantly, these projects helped me move from simply using generative AI to understanding how to build applications around generative AI.

Conclusion

The Gen AI Academy APAC Edition gave me the opportunity to move beyond learning generative AI concepts and actually build, test, and deploy AI agents on Google Cloud.

Across these hands-on codelabs, I explored how large language models can be connected with real-world data and tools to solve practical problems. From deploying Gemma 4 on Cloud Run, to analyzing Citi Bike data using ADK, BigQuery, and MCP, and finally building a Coffee Shop Agent capable of analyzing Google Sheets data and taking actions after human approval, each project introduced a different part of the agentic AI workflow.

One of my biggest takeaways was that the real power of AI agents comes from combining reasoning, tools, data, cloud infrastructure, and human oversight.

There is still much more for me to explore in Generative AI and agentic systems, but this experience has given me a practical foundation to continue building more capable AI applications.

I’m grateful to Google Cloud and Hack2skill for organizing the Gen AI Academy APAC Edition and providing an opportunity to learn through hands-on projects.

I look forward to continuing this journey and building more with Generative AI and Google Cloud.

Thanks for reading! ☕🤖