DEV Community: Jidnya

Personal Gemini Journal: A Secure AI Reflection App

Jidnya — Sun, 30 Aug 2026 13:23:29 +0000

🧠 Personal Gemini Journal: A Secure AI Reflection App with Gemini, Firebase & Cloud Run

Write → Reflect → Understand → Act

I built Personal Gemini Journal as part of the Google Cloud Run AI Challenge.

Traditional journaling helps us record our thoughts, but it doesn't always help us understand them. I wanted to build a private AI-powered journaling experience where users can reflect, have meaningful conversations with AI, and turn their thoughts into actionable insights.

🎯 Problem Statement

Users often struggle with:

Understanding recurring thoughts
Identifying patterns in their reflections
Organizing complicated thoughts
Turning reflections into practical actions
Reviewing their personal growth
Keeping personal journal data private

Most AI chat applications also aren't designed around persistent, user-isolated reflection sessions.

💡 Solution

Personal Gemini Journal combines private journaling with Google Gemini.

Users can create a reflection session and have a multi-turn conversation with Gemini. After reflecting, the application can generate structured insights from the complete session.

The core experience is:

Write → Reflect → Understand → Act

✨ Key Features

💬 Multi-Turn Gemini Conversations

Users can continue a contextual conversation with Gemini instead of receiving only a single AI response.

🧠 Reflection Insights

Gemini analyzes a completed reflection session and generates:

Key Insight — the central realization
Emotional Pattern — a strictly non-clinical observation
Recurring Theme — an important theme from the reflection
Action for Tomorrow — a practical next step
Growth Signal — a potential positive development or learning signal

✨ Session Synthesis

The Synthesis feature creates a higher-level understanding of the complete session, including:

Focus Title
Key Themes
Core Insight
Perspective
Actionable Takeaways

💾 Persistent Journal Sessions

Journal sessions and interactions are stored in Cloud Firestore, allowing users to:

Create multiple sessions
Reopen previous sessions
Continue conversations
Refresh the application
Sign out and sign back in
Access previous reflections

🔎 Search & Mood Filtering

Users can search previous reflections and organize them using mood categories.

📋 One-Click Action Copy

The generated Action for Tomorrow can be copied instantly.

📤 Journal Export

Users can export their personal journal data as a JSON archive.

🔐 Security

Privacy is a core part of the application because journal entries can contain personal information.

🔑 Firebase Authentication

Users authenticate through Firebase Authentication with Google Sign-In.

🗄️ User-Isolated Firestore

Journal data is organized using Firebase UID-based paths:

/users/{uid}/sessions
/users/{uid}/interactions
/users/{uid}/insights

Firestore Security Rules enforce that authenticated users can only access their own data.

🔒 Server-Side Gemini API

Gemini requests are handled through the trusted Express backend.

The Gemini API key is kept server-side and is not hardcoded into frontend code.

🔐 Secret Management

The deployment uses secure server-side secret handling with Google Cloud Secret Manager.

🛡️ Input Protection

The backend includes:

Request validation
JSON payload validation
Input length limits
Server-side sanitization

🏗️ Architecture

                    ┌──────────────────┐
                    │      USER        │
                    │    BROWSER       │
                    └────────┬─────────┘
                             │
                             ▼
                  ┌─────────────────────┐
                  │   React Frontend    │
                  │ React + TypeScript  │
                  └─────────┬───────────┘
                            │
               ┌────────────┴────────────┐
               │                         │
               ▼                         ▼
      ┌────────────────┐       ┌─────────────────┐
      │ Firebase Auth  │       │ Express Backend │
      │ Google Sign-In │       │      API        │
      └────────────────┘       └────────┬────────┘
                                        │
                                        ▼
                               ┌─────────────────┐
                               │  Google Gemini  │
                               │                 │
                               │ Chat            │
                               │ Insights        │
                               │ Synthesis       │
                               └─────────────────┘

               ┌─────────────────────────────┐
               │      Cloud Firestore        │
               │                             │
               │ UID-based private storage   │
               └─────────────────────────────┘

                         │
                         ▼
                 Google Cloud Run

🔄 Application Flow

User
 │
 ▼
Google Sign-In
 │
 ▼
Private Dashboard
 │
 ▼
Create Reflection
 │
 ▼
Multi-Turn Gemini Conversation
 │
 ▼
Save Session to Firestore
 │
 ├──────────────────┐
 ▼                  ▼
Reflection         Session
Insights           Synthesis
 │                  │
 └────────┬─────────┘
          ▼
Actionable Takeaways
          │
          ▼
Persistent Journal

🛠️ Technology Stack

Technology	Purpose
React 19	Frontend
TypeScript	Application development
Tailwind CSS	UI styling
Lucide React	Icons
React Markdown	AI response rendering
Express	Backend API
Google Gemini	AI reflection and analysis
`@google/genai`	Gemini SDK
Firebase Authentication	Google Sign-In
Cloud Firestore	Persistent user data
Google Cloud Secret Manager	Secret management
Google Cloud Run	Deployment
Vite	Frontend build
esbuild	Backend bundling

☁️ Google Cloud Run

The application was deployed from Google AI Studio to Google Cloud Run.

Cloud Run Service

personal-gemini-journal

Region

asia-southeast1

Challenge Label

dev-tutorial=cloud-run-ai-challenge

The Cloud Run deployment provides the production environment for the application, while the Express backend handles server-side Gemini requests.

🧪 Testing & Verification

The application was tested for:

Google Sign-In
Multi-turn Gemini conversations
Firestore persistence
User data isolation
Reflection Insights
Session Synthesis
Search and filtering
Journal export
Reload persistence
Sign-out/sign-in persistence
Cloud Run deployment

🌐 Live Application

🚀 Live App:
https://personal-journal-491827.ai.studio

💻 Source Code:
https://github.com/Jidnya-0926/personal-gemini-journal

🚀 Future Improvements

📊 Personal growth analytics
📈 Reflection trend visualization
🧠 Long-term reflection pattern detection
🔍 Semantic journal search
📱 Enhanced mobile experience
📅 Daily reflection reminders
🗺️ Location-aware journal entries
🔔 External notifications

🏆 Google Cloud Run AI Challenge

This project was built for the Google Cloud Run AI Challenge.

The application demonstrates how:

Google Gemini + Firebase Authentication + Cloud Firestore + Express + Google Cloud Run

can be combined to create a secure, authenticated and persistent AI application.

The focus was not just on connecting an AI model to a UI, but on building the surrounding architecture:

Authentication → Authorization → Data Isolation → Secure API Access → AI → Persistent Experience

🙌 Final Thoughts

Personal Gemini Journal is designed to make journaling more than simply storing thoughts.

It helps users pause, explore what they're thinking, recognize meaningful patterns, and identify what they can do next.

Write. Reflect. Understand. Grow.

Aayra: Building an AI Agent to Help Students Learn, Adapt, and Grow

Jidnya — Sun, 23 Aug 2026 16:33:06 +0000

The Problem

As an Information Technology student, I have seen how difficult it can be for students to decide what to learn, what to prioritize, and how to manage their time.

Students have different goals, skill levels, schedules, deadlines, and learning needs. A fixed timetable or a traditional productivity tool cannot always adapt to these changes.

This made me think:

What if an AI Agent could understand a student's situation, create a plan, monitor progress, and adapt when things change?

This idea led me to Aayra — an AI Agent for student growth and productivity.

Learn. Adapt. Grow.

What Is Aayra?

Aayra is an AI Agent designed to help students turn their goals into personalized and actionable plans.

Instead of simply answering questions like a chatbot, Aayra is designed to understand the student's context and help determine what they should focus on next.

The basic workflow is:

Student → Understand → Analyze → Plan → Act → Monitor → Adapt

It can consider information such as:

Goals
Current skills
Subjects
Areas of difficulty
Available time
Learning progress
Deadlines

The goal is to provide personalized next steps instead of generic advice.

How the AI Agent Works

Imagine a student says:

"I have five days before my DBMS exam. I can study two hours every day and I am weak in Distributed Databases."

Aayra can analyze the student's available time, deadline, and weak areas and create a prioritized learning plan.

If the student misses a study session, the agent can reconsider the remaining time and adjust the plan.

The process can be:

Understand → Analyze → Decide → Plan → Act → Monitor → Adapt

This makes Aayra different from a static timetable because the plan can respond to changes in the student's situation.

Example

Suppose a student wants to become a Full Stack Developer.

Their current skills are:

HTML, CSS, JavaScript

The AI Agent can identify potential next steps such as:

React → Backend → Database → APIs → Project

If the student's available time changes from two hours to one hour per day, the agent can adjust the plan and prioritize the most important tasks.

The objective is not to create a perfect plan once, but to continuously help the student decide what to do next.

Where Generative AI Fits

Generative AI allows students to communicate naturally with the system.

For example:

"I have college until 4 PM, two assignments due tomorrow, and I also want to practice DSA."

Instead of requiring multiple forms, the AI Agent can understand this context and use it to determine priorities.

Generative AI can support:

Natural-language understanding
Personalized planning
Learning recommendations
Practice generation
Explanations
Progress-based suggestions
Adaptive planning

The goal is not simply to generate text. The goal is to use AI to help students make decisions and take useful actions.

My Gen AI Academy APAC Journey

My participation in the Gen AI Academy APAC Edition is helping me explore how practical GenAI applications can be built and deployed.

Through the Academy, I am learning about technologies and concepts including:

Gemini, AI Agents, RAG, ADK, BigQuery, and Cloud Run.

The hands-on experience is helping me understand that a useful AI application needs more than an AI model. It needs:

A real problem + relevant context + reasoning + useful actions + a good user experience.

Challenges

Building an AI Agent also comes with challenges.

Personalization: Every student has different goals, skills, and schedules.

Reliability: AI recommendations need to be relevant and dependable.

Adaptation: The system needs to recognize when a plan should change.

Human Control: The AI should assist students while allowing them to review and control their decisions.

These challenges are also opportunities to learn and improve the system.

The Bigger Vision

My vision for Aayra goes beyond study schedules.

I want to explore how an AI Agent can support a student's broader journey:

Goals → Skills → Learning → Practice → Projects → Progress → Career

In the future, Aayra could help students identify skill gaps, discover learning paths, choose projects, prepare for opportunities, and adapt their learning journey.

The goal is not to make students dependent on AI.

It is to help them become more organized, aware of their progress, and confident about their next step.

What's Next?

I want to continue developing Aayra from an idea into a practical working system.

My next steps are to experiment with AI Agent workflows, relevant data, tools, cloud deployment, and real user feedback.

My approach is simple:

Find a problem → Build → Test → Learn → Adapt → Improve

Aayra is one step in my journey as a builder.

I believe students don't always need more information.

Sometimes, they simply need help answering:

"What should I do next?"

That is the problem I want to explore with Aayra.

Learn. Adapt. Grow.