My Journey Building the Automated Feedback Forms System

The Beginning: A Simple Request That Became an Adventure

It all started with a straightforward request: "I need to create Google feedback forms automatically when modules end in programs." Little did I know this would become one of the most interesting technical challenges I've tackled!

Phase 1: The Google API Approach (The Hard Way)

The Initial Plan

I thought this would be straightforward - just use Google's APIs to create forms programmatically. I started building a Node.js backend with Google Drive, Forms, and Sheets APIs. The architecture looked clean:

User clicks "Create Form" → Backend calls Google APIs → Form created → Link returned

The Reality Check

Oh boy, was I wrong! Google's APIs are like a maze with hidden doors. Here's what happened:

1. First Error: "Only info. Title can be set when creating a form"

• Me thinking: "Okay, that's weird but I can work around it"

• Reality: Google Forms API has strict rules about what you can set during creation

2. Second Error: "Google Forms API has not been used in project"

• Me thinking: "The user needs to enable the API, simple fix"

• Reality: This was just the beginning of our permission nightmare

3. The Big One: "Request had insufficient authentication scopes"

• Me thinking: "Let me check the service account permissions"

• Reality: This opened a can of worms about Google Workspace permissions

The Permission Nightmare

I discovered that to create Google Forms programmatically, you need something called "Domain-Wide Delegation" - which is basically Google's way of saying "only admins can do this." The user's response was the nail in the coffin:> "i am not the admin" My internal monologue: "Well, there goes that approach! Time to pivot."

Phase 2: The Google Apps Script Pivot (The Smart Way)

The Lightbulb Moment

I remembered Google Apps Script exists! It's like having a magic wand that runs in Google's cloud with the user's own permissions. No more service account headaches! The new plan: Build a web app that creates forms using Apps Script, then integrate it with the main ops app.

Building the Apps Script

This was actually fun! I built a comprehensive form creation system:

The UI Transformation

The original interface was basic HTML. I decided to make it look professional: Before: A simple form with basic styling After: A modern, responsive interface with:

• Drag & drop CSV upload

• Loading animations

• Professional color scheme

• Mobile-friendly design

The transformation was like going from a paper form to a sleek web app!

Phase 3: The Integration Challenge (The Fun Part)

The Auto-Detection Dream

I wanted the system to be as smart as possible. The user shouldn't have to manually enter program details every time. So I built multiple detection methods:

1. URL Parameters: Pass data directly from the ops app

2. Document Properties: Store program ID in Google Sheets/Drive

3. User Properties: Remember the last program used

4. MongoDB Bridge: Fetch data directly from the database

The Ops App Integration

This was the coolest part! I created a seamless flow:

text

User in Program Details → Clicks "Create Form" → 

Google Apps Script opens → Automatically detects program → 

Only asks for module name/number → Form created!

The user experience went from: "Fill out 10 fields manually “To: "Click button, enter 2 things, done!"

Phase 4: The Bug Hunt (The Reality Check)

The Syntax Error Saga

This was frustrating but educational. I kept getting syntax errors in the Apps Script:

text

What I learned: When building complex HTML strings in JavaScript, backslashes can be tricky. The issue was \\n vs \n in template literals. After fixing this multiple times, I now have a deep appreciation for proper string escaping!

The Duplicate Values Problem

Google Forms has a strict rule: no duplicate choices in multiple-choice questions. When learners have similar names or emails, this becomes an issue. My solution: Built deduplication logic both in the frontend and the Apps Script:

JavaScript

// Remove duplicates before creating form choices

Phase 5: The Final Polish (The Satisfaction)

The Complete System

By the end, we had built something really cool:

1. Automated Form Creation: Forms are created with the right structure automatically

2. Smart Data Detection: The system knows what program you're in

3. Professional UI: Looks like a commercial product

4. Seamless Integration: Works directly from the ops app

5. Error Handling: Gracefully handles edge cases

6. 

The User Experience Transformation

Before: User had to manually create forms, copy-paste learner lists, set up Google Drive folders, etc. After: User clicks one button, enters module details, and gets a fully functional feedback form ready to share!

What I Learned Along the Way

Technical Insights

1. Google APIs are powerful but complex - They have strict rules and permissions

2. Google Apps Script is underrated - It's like having a Swiss Army knife for Google Workspace

3. Frontend validation is crucial - Catch errors before they reach the backend

4. User experience matters - A few extra clicks saved can make a huge difference

Problem-Solving Lessons

1. Pivot when needed - The Google API approach was doomed from the start

2. Think user-first - What's the easiest way for someone to accomplish their goal?

3. Iterate and improve - Each version got better and more user-friendly

4. Test thoroughly - Real-world usage reveals issues you never thought of

The Human Element

The most interesting part was understanding the user's workflow. They didn't want to be developers - they wanted to create feedback forms quickly and get back to their actual work. Every feature I added was about reducing friction and making their life easier.

The End Result: A System That Actually Works

What We Built

• Automated feedback form creation for any program

• Smart program detection with multiple fallback methods

• Professional web interface that looks like a commercial product

• Seamless integration with the existing ops app

• Comprehensive error handling and user feedback

The Impact

Instead of spending 15-20 minutes manually creating each feedback form, users can now do it in under 2 minutes. That's a 10x improvement in efficiency!

The Satisfaction

There's something deeply satisfying about building a system that:

1. Solves a real problem (manual form creation is tedious)

2. Works seamlessly (no context switching between apps)

3. Looks professional (users feel confident using it)

4. Saves significant time (from 20 minutes to 2 minutes)

Final Thoughts

This project taught me that the best solutions often come from understanding the user's actual workflow, not just their stated requirements. The user said "I need automated feedback forms," but what they really needed was "I need to create feedback forms without leaving my workflow. “The pivot from Google APIs to Google Apps Script was crucial - it turned an impossible problem into a solvable one. And the focus on user experience made the difference between a functional tool and one that people actually want to use. The journey from "this should be simple" to "this is actually working beautifully" was both challenging and incredibly rewarding.