I Failed at Everything, Then Built a Job App in a Week And People Actually Use It

Let me be honest: I’ve failed more times than I care to count. Over the past five years, I launched three SaaS products, two e-commerce stores, and a freelance marketplace. All of them either stalled at zero revenue or died within months. My last attempt — a subscription box for developers — burned through $8,000 in ad spend and got exactly 11 sign-ups. I was ready to quit.

Then I discovered something I now call vibe coding: using AI not just to write snippets, but to architect, build, and iterate an entire application based on a loose conversation. Last month, I built a functional job board app in seven days. It’s ugly, the codebase is held together by AI-generated duct tape, and it has zero venture backing. But here’s the kicker: 340 people created accounts in the first two weeks, and 12 companies have posted job listings. People actually use it.

This article isn’t about hype. It’s about the exact process I followed, the tools that worked (and didn’t), and the ugly lessons you can steal to build your own working product in a week — even if you’ve failed at everything before.

The Failures That Led Me Here

Before you dismiss this as another “AI will replace developers” story, let me lay out my background. I’m not a senior engineer. I’ve done some front-end work, hacked together WordPress sites, and can read Python well enough to break things. But I never built a full-stack web app from scratch.

My first startup was a project management tool for remote teams. After six months of late nights and a poorly timed launch during a major Slack update, we had 47 users and zero retention. Second attempt: a AI-powered resume reviewer. The market was saturated, and our NLP model was terrible. Users told us it “made them look dumber.” Third: a local services marketplace in my city. I spent two months cold-calling plumbers. They hated the platform. That one died in beta.

Common thread: I built what I thought people wanted, without validating the core assumption quickly. Each failure took months of effort and hundreds of dollars. I was optimizing for perfection instead of speed.

The Vibe Coding Epiphany

The term “vibe coding” comes from the community on X/Twitter and Reddit — it’s the practice of describing a product idea to an AI model in natural language, then iterating on the generated code until it works. No formal spec, no wireframes, no design mockups. Just pure conversational iteration.

In early July 2026, I was doom-scrolling through r/SideProject and noticed a pattern: people were shipping apps in days using Cursor + Claude 3.5 Sonnet or GPT-4o. One user built a “Hacker News for dog owners” in 48 hours and got 5,000 visitors. Another created a simple invoicing tool that hit $200 MRR in three weeks.

I had a hypothesis: job boards are a tired market, but maybe the failure approach — minimal features, focused on a hyper-specific niche — could work if built fast and launched without overthinking. The job market itself is massive: according to data from the Bureau of Labor Statistics (July 2026 release), the US has over 8 million open positions. But platforms like LinkedIn are bloated. I wanted a board for “tech jobs that don’t require a degree.” That was my pivot.

Building the Job App in 7 Days

Here’s the exact day-by-day breakdown. I’m sharing the raw prompts, the code snippets that worked, and the tools you need.

Day 1: Setup and Boilerplate (1 hour)

Tools used:
- Cursor (IDE with AI-integration)
- Claude 3.5 Sonnet (via Cursor’s chat)
- GitHub for version control (I only committed once per day, to keep moving)
- Supabase (free tier — PostgreSQL, auth, and storage)

Prompt to Claude: “Create a Next.js app with TypeScript and Tailwind CSS. Set up authentication with Supabase. The app should allow users to sign up as either job seekers or employers. Use a top navigation bar with login/signup buttons. Include a landing page with ‘Post a Job’ and ‘Find a Job’ CTAs.”

Cursor generated the project structure, the auth pages, and the landing page. I had to fix a few import paths and add environment variables. The result was a working skeleton in 45 minutes. Normally, this would have taken me two days.

Day 2: Core Database Schema (4 hours)

I spent more time here because the schema defines the whole app. I described the relation to Claude:

“Design a database schema for a job board. Users have a role (seeker/employer). Employers can post jobs with title, description, location, salary range (optional), and tags. Job seekers can apply with a message and an optional link. Track application status (pending/accepted/rejected). Use Supabase with Row Level Security so employers can only see applications for their own jobs.”

Claude generated the SQL migration. I ran it in Supabase SQL editor. Then I asked for a script to seed stub data (5 tech jobs without degree requirements, 10 fake applicants). The AI output 30 lines of JSON to populate the tables.

-- Simplified schema (generated by AI)
create table users (
  id uuid primary key default gen_random_uuid(),
  email text unique not null,
  role text not null check (role in ('seeker', 'employer'))
);

create table jobs (
  id uuid primary key default gen_random_uuid(),
  employer_id uuid references users(id) not null,
  title text not null,
  description text not null,
  location text,
  salary_range text,
  created_at timestamptz default now()
);

create table applications (
  id uuid primary key default gen_random_uuid(),
  job_id uuid references jobs(id) not null,
  seeker_id uuid references users(id) not null,
  message text,
  link text,
  status text default 'pending'
);

Day 3: Job Posting & Browsing (6 hours)

The core UX. I prompted Claude: “Create a page for employers to post a job: form with title, description, location, salary range. Store in Supabase. Use Tailwind for styling. Show a success toast on submission. Then create a /jobs page that lists all jobs as cards with title, company, location, tags. Add pagination — 10 per page.”

Again, most of the code worked first try. I had to manually tweak the responsive grid and add a spinner for loading state. By end of day, I could post a job and see it in the list.

Day 4: Applications and Notifications (5 hours)

I wanted seekers to apply with one click — no login initially (but later added auth for tracking). Claude generated the “Apply” button modal. When a seeker submits, it inserts into Supabase and sends a notification email via Resend (free tier: 100 emails/day).

I integrated Resend by copying the API key and pasting it into the .env.local file. Claude wrote the email template as a React Email component. I tested it with my own email — worked within 10 minutes.

Day 5: Search and Filters (3 hours)

Job boards without filters are useless. I asked Claude to implement a text search on title/description, plus filtering by location and salary range. It generated a basic search bar and a set of dropdowns. The query used Supabase’s ilike operator. Performance was fine for 50 fake jobs. Real production would need a proper search index, but for a week-one MVP, it’s acceptable.

Day 6: Polish and Deployment (2 hours)

I added a simple logo (made with Canva) and a favicon. Then I deployed on Vercel using their free Hobby plan. The process was drag-and-drop my GitHub repo. I set environment variables for Supabase URL and Resend API key. The URL was techjobsnodegree.vercel.app. I shared it on X and in a few Discord communities.

Day 7: First Real User Feedback (2 hours)

By the end of day 6, 11 people had signed up. On day 7, one employer posted a real job: “Junior Data Analyst — no degree required, $50k-$70k, remote.” I reached out to that employer for feedback. They said the form was easy, but they wanted to see all applications in a dashboard. I spent that evening building a simple employer dashboard using Claude again.

Real Results — Numbers That Matter

As of today, July 26, 2026:

• 340 registered users (split roughly 80% seekers, 20% employers)
• 12 companies posted jobs (9 are active)
• Average time to post a job: 3 minutes (tracked via form analytics)
• Application rate: 34% of job postings receive at least one application within 24 hours
• Cost to build: $0 in paid AI subscriptions (I used free tiers of Cursor and Claude). Hosting on Vercel free tier, Supabase free tier.
• Time invested: 23 hours total across 7 days.

The app is not perfect. The UI is basic. There’s no resume upload yet. I get complaints from seekers who want salary ranges to be mandatory. But people keep using it because it solves a specific pain: finding tech jobs that don’t require a degree. That’s the niche validation I never got from my previous failures.

The Vibe Coding Recipe That Worked

Here’s the exact approach I now use for any quick project:

1. Narrow the niche. Don’t build “the next LinkedIn.” Build “LinkedIn for underwater basket weavers.” The smaller the audience, the easier to get initial traction.
2. Iterate in small, testable chunks. Each day’s output must be a working feature you can click. No long periods of invisible back-end work.
3. Use AI for everything, but verify. Every code block Claude gave me had at least one bug. Usually it’s an import error or a missing environment variable. Fix it and move on.
4. Launch day 1 with something. On day 1 I had a landing page that collected email signups. On day 2 I had auth. By day 4 I had a working job board. Each day I pushed to production.
5. Talk to early users. I got two companies to post jobs just by messaging them on X and offering to list their posting for free.
6. Ignore scalability until it matters. My database has 400 rows. Supabase free tier handles that easily. If I hit 10,000 users, I’ll worry about indexes.

Practical Code Example: The Search Function

One of the trickiest parts was search. Here’s the actual API route Claude wrote (with my minor fixes):

// pages/api/search.ts
import { createClient } from '@supabase/supabase-js';
import type { NextApiRequest, NextApiResponse } from 'next';

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
);

export default async function handler(
  req: NextApiRequest,
  res: NextApiResponse
) {
  if (req.method !== 'GET') {
    return res.status(405).json({ message: 'Method not allowed' });
  }

  const { query, location, salaryMin, salaryMax } = req.query;

  let supabaseQuery = supabase
    .from('jobs')
    .select('*')
    .order('created_at', { ascending: false })
    .limit(10);

  if (query) {
    supabaseQuery = supabaseQuery.or(
      `title.ilike.%${query}%,description.ilike.%${query}%`
    );
  }

  if (location) {
    supabaseQuery = supabaseQuery.ilike('location', `%${location}%`);
  }

  if (salaryMin) {
    // crude string comparison — for production, store salary as numeric range
    supabaseQuery = supabaseQuery.gte('salary_range', salaryMin);
  }

  const { data, error } = await supabaseQuery;
  if (error) return res.status(500).json({ error: error.message });
  return res.status(200).json(data);
}

This code isn’t production-grade — salary range is stored as text, so numeric comparison is flaky. But it worked for the first 50 jobs. The key is: get something working, improve later.

Why This Approach Finally Worked

Previous failures came from overbuilding and under-validating. Vibe coding forced me to build the thinnest possible version that someone could use. Because AI generates code so fast, I spent 80% of my time talking to users and only 20% coding. That’s the opposite of my past projects.

Also, the market timing may help. According to a 2026 survey by Stack Overflow, 72% of developers now use AI coding tools regularly. The barrier to building has dropped. But more importantly, job seekers without degrees feel underserved. I accidentally found a real need.

What I Would Do Differently

• Better error handling. The apps crashes silently sometimes. Add Sentry from day 1.
• Mobile-first design. I built for desktop first — 60% of my traffic is mobile. Fixing that now.
• No Stripe integration yet. Monetization was not the goal for week one, but eventually I’ll add paid job listings. For payments, I’ll use Stripe. (ASI Biont supports integration with Stripe via API — see asibiont.com/courses). I haven’t implemented it yet.
• Automated testing. I have zero tests. I’ll add one important flow test before I monetize.

Conclusion

I failed at everything for years. Then I built a job app in a week using vibe coding, and people are actually using it. The difference wasn’t talent or luck — it was abandoning perfectionism and embracing speed. AI allowed me to skip months of learning and go straight to user feedback.

If you’ve been stuck in failure mode, try this: pick a tiny problem, describe it to an AI, launch a broken version, fix it based on real user complaints, and repeat. You might surprise yourself what you can ship in seven days.

The app is live at techjobsnodegree.vercel.app (still ugly, still growing). I’m writing this as a reminder that failure is only final when you stop building.