Prototype case study
Building and testing an AI-assisted creative-product prototype.
How IKECOZ prototyped a Node.js and Gemini-assisted creative tool — environment configuration, server setup, and iterative feature testing without overstating production readiness.
- JavaScript
- Node.js
- Gemini API
- Environment configuration
- Web UI
Project snapshot
At a glance.
Project snapshot
- Project type
- Prototype
- Context
- IKECOZ experimental AI product work
- Status
- Prototype
- Platform
- Local web prototype (Node.js server + browser UI)
- Primary technologies
- JavaScript, Node.js, Gemini API
- Role / responsibility
- Prototype engineering and integration
- Development model
- Iterative prototype with local testing
- Related service areas
- AI automation, web development, custom software, API integration
Context
Project background.
Creatiq is an experimental AI-assisted creative prototype — not a client delivery or commercial SaaS platform. This case study documents how a simple Node.js server, environment-based API configuration, and browser interface were used to test generative creative workflows.
Challenge
The problem to solve.
Explore whether AI-assisted creative drafting could be made useful through a coherent local prototype — without exposing secrets, inventing user metrics, or presenting experimental tooling as a finished product.
Goals
What the work aimed to achieve.
- Integrate an external generative AI API through secure environment configuration
- Provide a browser-facing interface for creative input and output review
- Test caption, copy, and voice-related interaction paths where implemented
- Resolve startup, directory, and environment issues systematically
- Establish a prototype foundation that could inform a future product decision
Audience
Users or intended audience.
- Founders evaluating AI-assisted content workflows
- Creative teams exploring generative tooling concepts
- IKECOZ engineering review of API-integrated prototypes
Constraints
Boundaries that shaped decisions.
- API keys and environment secrets must never be published
- No verified production hosting, billing, or user authentication to claim
- Generative outputs require human review — reliability cannot be overstated
- Feature lists must reflect tested prototype behaviour, not roadmap fantasy
Research
What was explored first.
The prototype explored where AI assistance adds value in creative workflows — drafting, caption-style outputs, and copy interactions — versus where a human editing loop remains essential.
Planning
How scope was structured.
Planning kept the architecture small: a Node.js entry point, environment-driven API configuration, and a web UI layer suitable for local iteration.
Experience design
Interface and experience direction.
The interface direction prioritized clear separation between user input, generated suggestions, and editable results — avoiding a raw developer-console feel.
Technical approach
How the work was engineered.
Creatiq-related work used a Node.js project with a server entry point, dependency installation via npm, and local startup through npm start. Generative requests were configured through environment variables (including a Gemini API key stored outside source control). Browser-facing functionality was tested for creative outputs such as captions and copy interactions, with voice-related behaviour explored in prototype iterations.
Architecture
Verified prototype structure
Local prototype flow confirmed in development records. Production infrastructure, databases, and auth are omitted because they are not verified for this phase.
- Browser UI: Creative input, output review, copy interactions
- Node.js server: Local application server and request handling
- Environment config: API credentials outside source control
- Gemini API: External generative model integration
Development process
How the work progressed.
Development process
- 01Set up the Node.js project and dependencies
- 02Configure environment variables for the generative API
- 03Implement server routes and browser-facing interactions
- 04Test caption, copy, and voice-related prototype paths
- 05Resolve directory and startup issues during local runs
- 06Iterate on output review and editing workflows
Important features
What was implemented or validated.
Important features
- Node.js server for local prototype delivery
- Environment-based Gemini API configuration
- Browser interface for creative input and output review
- Caption and copy interaction testing
- Voice-related functionality explored in prototype iterations
Challenges and debugging
What failed, how it was investigated, and what changed.
Challenges and debugging
Prototype failed to start from the wrong directory
- Challenge
- The server did not start because commands were being run from an incorrect project location.
- Response
- The working directory was confirmed, dependencies were reinstalled from the correct root, and the server was restarted with the required environment configuration in place.
Environment configuration missing at runtime
- Challenge
- Generative requests failed when required API credentials were not available to the running process.
- Response
- Environment variable loading was verified, secrets were kept out of source control, and the server was restarted only after configuration was confirmed locally.
Feature behaviour differed across creative output modes
- Challenge
- Caption, copy, and voice-related paths did not behave consistently during early testing.
- Response
- Each interaction path was tested independently, expectations were adjusted, and the UI was iterated to make generated output easier to review and edit.
Testing
How behaviour was validated.
Testing was local and manual: dependency install, server startup, browser interaction, and verification that configured generative requests returned usable output for review. No production load, privacy, or billing scenarios were validated in this prototype phase.
Outcome
Honest project outcomes.
Outcome
- A working local Node.js prototype foundation was established
- The configured generative API integration communicated successfully during testing
- Caption and copy interactions were exercised in the browser
- Startup and environment issues were resolved systematically
- The prototype is prepared for further product validation decisions
Lessons learned
What the work reinforced.
Lessons learned
- Environment configuration should be validated before debugging feature logic
- AI prototypes need explicit human review loops in the interface
- Small architectures are easier to reason about during early experiments
- Secrets belong in environment configuration — never in public case study content
Current status
Where the project stands today.
Creatiq remains a prototype and experimental AI product. It is not presented as a production SaaS platform, commercial release, or client project.
Future improvements
Possible next steps — not completed features.
Future improvements
- Production-grade authentication and authorization
- Secure backend deployment with rate limiting
- Privacy controls and data retention policies
- Expanded automated testing for API integration paths
- Clearer model-selection and output-review tooling
- Accessibility and mobile layout refinement
Related services
Delivery capabilities connected to this work.
Related services
AI Automation
Practical AI and automation that remove busywork — applied where it improves speed, consistency, or decision support.
Web Development
Modern web products that load quickly, communicate clearly, and support the journeys that matter to your business.
Custom Software
Purpose-built systems designed for your workflows, users, and growth — not forced into a generic template.
API & Cloud
APIs, integrations, and cloud foundations that keep products connected, secure, and ready to grow.
FAQ
Questions about the Creatiq case study.
Honest answers about context, status, and availability.
Frequently asked questions
Have a software problem worth solving?
Share your idea, existing system, users, constraints, and desired outcome with IKECOZ.