DEV Community

Cover image for How I Built and Deployed a Campus Marketplace (FlexStore) as a Solo Dev: Architecture & Lessons Learned
Ifeoluwa Banmeke
Ifeoluwa Banmeke

Posted on

How I Built and Deployed a Campus Marketplace (FlexStore) as a Solo Dev: Architecture & Lessons Learned

#webdev #javascript #architecture #indiedev

Let’s be real: as a student and solo developer, building products isn't about configuring Kubernetes clusters or orchestrating enterprise microservices. It’s about staring at a very real, very annoying campus problem, opening your code editor, and figuring out how to ship a working solution before your next exam.

For me, that problem was student commerce. Buying a textbook or selling a gadget on campus was entirely fragmented—buried deep inside WhatsApp status views, scattered across chaotic group chats, or trapped on legacy classifieds that felt like they were built in 2008.

So, I built FlexStore: a lightweight, web-based campus marketplace designed to make peer-to-peer student trading actually feel seamless.

Here is a breakdown of how I designed the architecture, the tech stack choices that kept my sanity intact, and the lessons learned shipping it solo.

1. The Engineering Requirements

Before writing a single line of code, I mapped out three non-negotiable constraints:

  • Mobile-First is Mandatory: 99% of students are browsing on their phones while walking to lectures. If it isn't lightning-fast on mobile data, it's useless.
  • Zero-Latency Communication: Building an isolated, in-app chat system that students have to log into separately is a recipe for low conversion.
  • Lean Infrastructure: Zero budget means leveraging modern BaaS (Backend-as-a-Service) layers to skip writing repetitive server boilerplate.

2. The Tech Stack & Architecture

To move fast without sacrificing scalability, I leaned into a modern, developer-friendly stack optimized for rapid iteration and performance.

  • Frontend & Architecture: Built around a Progressive Web App (PWA) mindset. Utilizing a fast build setup with Vite alongside framework routing (Next.js) allowed for instant client-side transitions and optimal asset delivery.
  • Backend & Database: Supabase handled the heavy lifting. Instant authentication, a robust PostgreSQL database, and real-time subscription capabilities meant I could spin up secure user roles and dynamic product feeds in hours instead of weeks.
  • AI-Assisted Workflow: As a solo dev, AI acted as my virtual co-pilot—speeding up component scaffolding, handling edge-case debugging, and letting me focus purely on user experience logic.

The Architecture Highlight: The WhatsApp Bridge

Instead of building a heavy internal chat system, I implemented a WhatsApp Bridge.

When a student clicks on a listing they like, the app dynamically constructs a pre-filled WhatsApp message containing the item details and routes them straight to the vendor's DMs. It completely eliminates push-notification infrastructure overhead while meeting users right where they already hang out.

// Example: Dynamic WhatsApp redirect payload generator
const handleWhatsAppInquiry = (item, sellerPhoneNumber) => {
  const message = encodeURIComponent(
    `Hi, I saw your listing for "${item.title}" on FlexStore priced at ₦${item.price}. Is this still available?`
  );
  window.open(`[https://wa.me/$](https://wa.me/$){sellerPhoneNumber}?text=${message}`, '_blank');
};
Enter fullscreen mode Exit fullscreen mode

3. Making It Discoverable: SEO & Performance

A great product sitting on an unindexed domain helps nobody. To ensure FlexStore gained organic traction across campus searches, I baked SEO straight into the core architecture:

  • ** Dynamic Open Graph Tags:** Ensuring that every time a product or store link is dropped into a WhatsApp group chat or Twitter thread, it renders a gorgeous, media-rich preview card.

  • Structured Data (JSON-LD): Giving search crawlers clear schema definitions for products, categories, and pricing.

  • Asset Caching: PWA service workers caching critical shell assets so repeat visits load instantly, even on terrible campus Wi-Fi.

4. Hard-Earned Lessons from the Trenches

  • PWA > Native Apps for Campus Tools: Forcing students to download an APK or visit an app store adds friction. A well-optimized PWA that installs straight from the browser is the ultimate growth hack.

  • Lean Into Existing Habits: Don't reinvent user behavior. By routing transactions through WhatsApp instead of a custom chat engine, I saved weeks of backend work while improving user trust and conversion.

  • Ship Before You're Ready: Perfection is just procrastination in disguise. Pushing an MVP live, breaking things, and fixing them based on real peer feedback teaches you more in a week than building in a vacuum for six months.

Final Thoughts

  • Building FlexStore reinforced a core belief: a single developer armed with the right modern tooling, AI assistance, and an obsession with a real user problem can build production-grade software that rivals entire teams.

  • If you're an indie hacker or student staring down a project idea: stop overthinking the stack, build the core loop, and just ship it.

Curious about the Supabase schema, the PWA caching strategy, or how the WhatsApp redirect handles payloads? Drop a comment below!

Top comments (0)