Shipping a product in 13 days is not for the faint-hearted. It’s a whirlwind of strategic decisions, caffeine-fueled coding sprints, and rapid validations. With 45+ products built across IoT, SaaS, marketplaces, and consulting under my belt, I decided to see if I could pull off a personal challenge: launching UTMStamp, a simple tool to generate, track, and manage UTM codes, in under two weeks. Here’s a day-by-day breakdown of how it happened.
Day 1: Idea Validation and Scope Definition
What Was Built
The first day was all about setting the stage. I began with a problem I had faced countless times: managing UTM parameters for marketing campaigns. It’s mundane yet crucial, and the existing tools were either too complex or too simplistic.
Decisions Made
- Scope: The MVP would focus on generating and storing UTM parameters. Advanced analytics and integrations could wait. The aim was to create something useful yet simple.
- Target Audience: Marketers and small business owners who regularly run digital campaigns.
Tools Used
- Google Forms: For quick surveys to validate interest.
- Slack: Reach out to my network for initial feedback.
What Was Cut
- Complex analytics dashboard. It wasn’t necessary for the MVP.
Day 2: Tech Stack Choices
Why Next.js and Supabase?
Choosing the right tech stack was crucial for this rapid build. I settled on Next.js and Supabase for several reasons:
- Next.js: Offers a balance of performance and ease of use. Ideal for server-side rendering, which was perfect for our needs since speed and SEO were priorities.
- Supabase: A managed backend service that provides an instant API and real-time capabilities. It’s like Firebase but with PostgreSQL, which I prefer for its robustness and familiarity.
Other Tools
- Vercel: For seamless Next.js deployment.
- Tailwind CSS: Fast, utility-first CSS framework to speed up styling.
Midnight Coding
I spent the evening setting up the project structure, ensuring that I could deploy a “Hello World” on Vercel by midnight. It’s a small win that set the momentum.
Day 3: Wireframes and Basic UI
What Was Built
Created wireframes outlining the core user flows: UTM creation and management.
Decisions Made
- Minimal UI: Focus on functionality over aesthetics. The UI had to be intuitive, but I avoided unnecessary embellishments.
Tools Used
- Figma: Rapid wireframing and prototyping.
What Was Cut
- User onboarding tutorials. Decided to rely on intuitive design instead.
Day 4: Setting Up the Backend
What Was Built
Structured the database in Supabase to handle users and UTM data.
Decisions Made
- Schema Design: A simple schema with tables for users and UTM entries, keeping future scalability in mind.
Tools Used
- Supabase SQL Editor: For quick schema adjustments.
What Was Cut
- Any form of user role management. All users would have the same capabilities initially.
Day 5: Frontend Development Begins
What Was Built
Started coding the frontend, focusing on the main dashboard where users would generate and view UTMs.
Decisions Made
- Component Library: Decided to stick with basic React components to keep things simple and light.
Tools Used
- React Hooks: For managing state and side effects.
Midnight Coding
First real functional React components were wrapped up. The dashboard could now display static data, which made the product feel tangible.
Day 6: Authentication and User Management
What Was Built
Implemented basic authentication using Supabase Auth.
Decisions Made
- Auth System: Email and password-based signup and login. No OAuth for now to keep things straightforward.
Tools Used
- Supabase Auth API: Quick integration with Next.js.
What Was Cut
- Social login options like Google or Facebook. Added complexity without immediate benefit.
Day 7: UTM Generation Logic
What Was Built
Wrote the core logic for generating UTM codes.
Decisions Made
- Parameter Flexibility: Allowed users to add custom parameters beyond the standard Campaign, Source, Medium, etc.
Tools Used
- JavaScript: Simple functions to construct UTM strings.
What Was Cut
- Predefined templates for common campaigns. Planned for a future update.
Day 8: UTM Management Interface
What Was Built
Added interfaces for viewing and managing existing UTMs within the dashboard.
Decisions Made
- List View: Opted for a simple list layout with search and filter capabilities.
Tools Used
- React Table Library: Quickly implemented sortable and searchable tables.
Midnight Coding
A bug in the table pagination took longer than expected, turning into an unexpected late-night session.
Day 9: Testing and Bug Fixing
What Was Built
Focused on testing and fixing bugs in the existing features.
Decisions Made
- Testing Approach: Manual testing over automated due to time constraints, focusing on critical paths.
Tools Used
- Chrome DevTools: For testing and debugging.
What Was Cut
- Automated testing scripts. A luxury for a 13-day build.
Day 10: Preparing for Launch
What Was Built
Finalized the product for launch, ensuring that everything was running smoothly.
Decisions Made
- Launch Strategy: Soft launch to a small group of trusted users for feedback.
Tools Used
- MailerLite: To reach out to the initial test group.
Midnight Coding
Tweaked the email notification system to ensure it didn’t end up in spam folders.
Day 11: Go Live!
What Was Built
Went live with UTMStamp to the closed group.
Decisions Made
- Feedback Loop: Created a simple Google Form for collecting user feedback.
Tools Used
- Vercel: Monitored deployments and fixed hot issues in real-time.
The First User
The first official user was from my Slack network. Their feedback highlighted a minor UI confusion, which was swiftly addressed.
Day 12: Responding to Feedback
What Was Built
Implemented quick fixes based on early feedback, mainly UI tweaks and minor bug fixes.
Decisions Made
- Iterate Quickly: Prioritized feedback that could be addressed in under an hour.
Tools Used
- Notion: For organizing feedback and bug tracking.
What Was Cut
- Larger feature requests. Not ignored, but deferred for post-launch.
Day 13: Public Launch and Reflect
What Was Built
Made UTMStamp publicly available and initiated a broader outreach.
Decisions Made
- Marketing Push: Minimal, relying on word-of-mouth and existing contacts.
Tools Used
- Twitter and LinkedIn: For announcing the launch.
Midnight Reflection
Reflecting on the journey, I realized this was the fastest I had ever moved from concept to launch. The tight deadline forced me to make decisive cuts and focus solely on what truly mattered for the MVP.
Successes and Lessons Learned
What Worked
- Rapid Iteration: The tight timeline forced focused decision-making and rapid iteration, which kept the project moving forward.
- Simple Tech Stack: Choosing Next.js and Supabase was a game-changer. Their ease of use allowed me to focus more on product functionality and less on infrastructure.
- Feedback Loop: Immediate feedback post-launch helped in refining the product quickly.
What Didn’t Work
- No Automated Testing: The absence of automated tests meant manual testing took longer, and some bugs were overlooked until user reports came in.
- Limited Marketing: Relying on organic reach limited initial user acquisition.
Conclusion
Shipping UTMStamp in 13 days was an intense ride but incredibly rewarding. It was a testament to the power of focus, strategic decision-making, and leveraging the right tools. For anyone dreaming of launching a product quickly, remember that constraints can be your best ally. They force you to deliver what truly matters. Here’s to the next lightning-fast build!
