Zapply - From Problem to MVP

Applying for remote jobs can be a daunting and repetitive process, especially for software engineers like me. After years of navigating job boards, filling out endless forms, and keeping tabs on daily updates, I realized something had to change. Instead of wasting hours every week, I decided to automate the process with a minimalist yet powerful tool designed to solve this exact problem. Here’s how I’m approaching the problem, defining an MVP, and setting out to build it in just 30 days.

The Problem

As a remote software engineer, finding and applying for remote jobs is frustratingly time-consuming. The process looks like this:

1. Keep job sources up to date and check them daily.
2. Sort through new postings to find ones that match your skills and preferences.
3. Fill out repetitive application forms over and over again.

Even with tools like email job alerts, the manual work doesn’t go away—you still have to visit the sites, sift through irrelevant jobs, and manually apply. The entire process is boring, repetitive, and eats up valuable time that could be spent coding, learning, or doing anything else.

The Solution

A tool that automates the entire process of applying for remote jobs with minimal user interaction. The idea is simple:

• The user uploads their CV and provides minimal input and configuration
• The tool automatically:
  • Maintains a list of job sources and checks for updates.
  • Matches jobs to the user’s profile based on their CV and filters/config.
  • Fills out application forms and applies to jobs.
  • Generates reports on what was done (e.g., jobs found, applications submitted).

In the future, the tool can evolve to include features like scheduling applications, managing multiple CVs, and integrating with more job sources.

Monetization

The tool will follow a freemium model:

• Free Tier: Users can apply to a limited number of jobs per day.
• Premium Tier: A paid plan removes limits and offers advanced features (e.g., custom job sources, scheduling, or detailed reporting).

The goal is to make it accessible for job seekers while monetizing users who want more power and flexibility.

The Complexity

Building this tool comes with significant technical challenges:

1. Job Source Maintenance

• Some job boards offer APIs, but not all have the features needed (e.g., API lacks filters and other limitations).
• Scraping may be necessary, which introduces complexities like handling bot protections.

2. Application Automation

• Filling out forms programmatically can be tricky, especially with captchas and varying form structures.

3. PDF Parsing and Job Matching

• The tool needs to analyze uploaded CVs to understand skills and match them with relevant job listings.

It’s a complex problem with many moving parts, but the potential payoff—both for me personally and for others—is worth the effort.

Defining the MVP

Given the complexity of the problem, I’ve decided to start with a minimal and focused MVP. The goal is to solve my core problem as a remote software engineer: automating applications for relevant jobs on a single job board of my choice.

Here’s what the MVP will include:

• CV Upload: Users can upload their CV (PDF or DOCX).
• Minimal Configuration: Users can set filters like:
  • Keywords (e.g., “Java”).
  • Location preference (e.g., “Remote/Anywhere”).
  • Time range (e.g., “Last 1–2 weeks”).
  • Etc.
• Job Fetching: The tool fetches job postings from a single job board of my choice, filtering them based on user input.
• Application Automation: The tool applies to matching jobs on behalf of the user and ensures it doesn’t apply to the same job twice.
• Report Generation: A simple report on the same page or email showing:
  • Total jobs fetched.
  • Jobs applied to.
  • Any errors encountered.

Challenges for the MVP

• Job Source Integration
  • Single job board of my choice provides an API, but it lacks essential features like filtering and number of jobs provided (not all, not premium)
  • Scraping is the alternative but adds complexity and bot protections.
  • I’ve reached out to the founder to see if they can extend their API, but this is still uncertain.
• Keeping It Slim
  • While future versions can include advanced features like scheduling or multi-platform integration, the MVP must stay minimal and focused on doing one job exceptionally well.

The Plan

To keep the project on track, I’ve set a 30-day timeline to build the MVP. During this time, I’ll focus on:

• Building the Core Workflow
  • Uploading a CV and parsing
  • Setting filters
  • Fetching jobs
  • Matching
  • Applying
  • Reporting
• Making Key Decisions
  • Decide whether to use the API (faster but limited) or scrape the site (more robust but complex).
• Testing on Myself:
  • As the primary user, I’ll run the tool on my own job search to refine and improve it.
• Preparing for Feedback
  • Once the MVP is live, I’ll collect feedback and iterate based on real-world usage.

Why This MVP Matters

This MVP isn’t just about solving my own problem—it’s a stepping stone for learning and validating the indie hacking process. It allows me to practice everything from defining a problem and building a product to collecting feedback and iterating. Even if the tool only ends up working for me, that’s a win because it saves me time and frustration.

Final Thoughts

By focusing on a specific, real-world problem and keeping the MVP as slim as possible, I’m giving myself the best chance to succeed. The next 30 days will be all about execution, learning, and making sure this tool delivers on its promise: automating job applications, so users can focus on what really matters.

If this resonates with you or solves a similar problem you’re facing, stay tuned—I’ll share updates as I build and test this tool.