Four years ago, I started JobBoardSearch with a static HTML file containing around a dozen niche job boards.
Today, it has:
800+ niche job boards
A searchable database of jobs
26K members in the subreddit
6K+ members in the Telegram community
Multiple revenue streams
$100K+ in lifetime revenue
And the funny thing is that the technology behind it is still pretty simple.
It's mostly PHP, vanilla JavaScript, raw CSS and SQLite.
I didn't start with a big architecture.
I just kept building useful things around the same data.
It started with a static HTML file
The original idea was very simple.
I wanted to create a directory of niche job boards.
There are job boards for almost everything: developers, designers, healthcare, climate, remote work, startups, specific technologies, industries, locations, and hundreds of other niches.
So I created a simple HTML page and added around a dozen of them.
That was the whole product.
No database.
No job feeds.
No bots.
No marketplace.
No fancy frontend.
Just a list of links.
Then job board owners started submitting their own boards.
That's when things started getting interesting.
I didn't scrape the job boards
One thing I'm particularly proud of is that I never scraped job boards to build the database.
The 800+ job boards currently listed on JobBoardSearch were submitted organically by their founders.
If someone wanted their job board listed, they submitted it.
Over time, many of these job boards started providing job feeds.
Some use APIs.
Some use XML.
Some use RSS.
So I built the infrastructure to fetch those feeds.
At first, I just wanted to show the jobs.
Then I started asking myself:
What else can I do with this data?
That question ended up shaping most of the product.
One feed became many features
The basic architecture is surprisingly simple.
Plain textANTLR4BashCC#CSSCoffeeScriptCMakeDartDjangoDockerEJSErlangGitGoGraphQLGroovyHTMLJavaJavaScriptJSONJSXKotlinLaTeXLessLuaMakefileMarkdownMATLABMarkupObjective-CPerlPHPPowerShell.propertiesProtocol BuffersPythonRRubySass (Sass)Sass (Scss)SchemeSQLShellSwiftSVGTSXTypeScriptWebAssemblyYAMLXMLJob Board | v RSS / XML / API | v Feed ingestion | v JobBoardSearch | +----> Job Search | +----> Job Board Pages | +----> SEO | +----> Reddit Bot | +----> Telegram Bot | +----> AI citations
The important part is that I didn't create a separate data pipeline for each feature.
The same job feed powers most of them.
The "meta" part
Every job board listed on JobBoardSearch has its own page.
If that job board provides a feed, I can display its current jobs on that page.
I call this the "meta" part of JobBoardSearch.
It's basically a job-search layer on top of the individual job boards.
And again, I'm not scraping their websites.
The job board provides the feed, and I consume it.
This also creates a useful relationship with the job board owners.
They get another place where their jobs can be discovered, while I get structured job data that I can use throughout the platform.
The Reddit bot
Once the feeds were working, I started looking for other ways to distribute the jobs.
I built a bot that automatically posts jobs to the JobBoardSearch subreddit every hour.
That subreddit has grown to around 26K members.
The nice thing is that I didn't need to manually create content for Reddit.
The content was already being generated by the feeds.
So the same infrastructure that powers the website also powers the subreddit.
The Telegram bot
Then I built a free Telegram bot.
The idea was to let job seekers receive personalized job alerts instead of having to constantly search for jobs themselves.
Users can configure things like:
Keywords
Locations
Industries
Roles
Notification cadence
The bot then uses the same job feed data to find relevant jobs.
The Telegram community has grown to more than 6K members.
Again, no new data source.
Just another way of using the same data.
This became a data flywheel
At some point, I stopped thinking about JobBoardSearch as a directory.
The directory was just the starting point.
The feeds became the underlying infrastructure.
And that infrastructure started powering several distribution channels:
Job search → SEO → Reddit → Telegram → AI citations
That was a big lesson for me.
You don't always need to build another product from scratch.
Sometimes you already have a useful piece of infrastructure.
You just need to find another way to expose it.
SEO became a major distribution channel
The job-board pages naturally create a lot of long-tail pages.
Every job board gets its own page.
Jobs can be discovered through the search engine.
Then I started building free tools for job board founders and job seekers.
Some are SEO tools.
Some help job board owners.
Others are useful for job seekers.
They provide value by themselves, but they also create additional pages and entry points into the site.
Over time, SEO became one of the biggest acquisition channels for JobBoardSearch.
And now I'm also seeing more visibility from AI-generated answers and citations.
That's something I'm still experimenting with.
The tech stayed simple
One of the things I find funny about the project is how little the technology has changed.
It's still mostly:
PHP + SQLite + vanilla JavaScript + raw CSS
I started it partly inspired by levelsio's approach of keeping things simple.
And I've been tempted MANY times to rewrite everything.
Use a modern frontend framework.
Redesign the UI.
Clean up the code.
Make the architecture more elegant.
Basically, rebuild the whole thing.
But every time I seriously considered doing it, I asked myself:
Will this actually make the business better?
Sometimes there were things that genuinely needed to be fixed.
But a lot of the time, I just wanted to rewrite things because I didn't like looking at old code.
Those are two very different things.
So instead of rewriting everything, I kept adding useful features.
The moat isn't the technology
I don't think the technology is the moat.
The code isn't particularly complicated.
The moat is everything that has accumulated around the project over four years.
Today that includes:
800+ job board relationships
A large amount of job data
Organic search traffic
SEO authority
26K Reddit members
6K+ Telegram members
Free tools
Search infrastructure
Multiple revenue streams
A marketplace
Relationships with job board founders
Someone could probably rebuild the basic website.
But they can't instantly recreate four years of accumulated traffic, data, communities and relationships.
That's the part I value most.
Then I started adding revenue
Once the platform had traffic and an audience, I started experimenting with monetization.
Today JobBoardSearch has multiple revenue streams:
Featured listings
Advertising
Affiliates
Directory Submission Service
SEO audits
Marketplace commissions
Other services for job board owners
Some job boards have been sponsoring continuously for 10+ months.
Others have been buying recurring featured listings since the early days.
That's actually more interesting to me than the $100K milestone.
A one-time purchase is nice.
But when someone keeps paying for months, you know you're providing some ongoing value.
The marketplace
At some point I realized there was another business opportunity around the same audience.
People wanted to buy and sell job boards.
So I built a marketplace for that.
Again, I didn't need to start from zero.
I already had the audience.
Job board founders were already using JobBoardSearch.
Some wanted to grow their boards.
Some wanted to sell them.
Some wanted to buy them.
So I added another layer to the existing ecosystem.
I also built free tools
Another thing I've done over the years is build free tools.
Some are for job board founders.
Others are for job seekers.
The idea is simple:
Build something useful → get discovered → provide value → bring people into the ecosystem.
And yes, SEO is part of the reason I build them.
But I try to make the tools genuinely useful first.
The SEO benefit comes second.
$100K wasn't the goal
When I created that first HTML file with a dozen job boards, I wasn't thinking:
"I'm going to build a $100K business."
I was thinking:
"This could be useful."
Then I kept adding things.
A dozen job boards became hundreds.
A static HTML page became a database.
The database became a search engine.
The feeds became a data pipeline.
The data pipeline became Reddit and Telegram bots.
The traffic became revenue.
The revenue became more products.
And four years later, the project passed $100K in lifetime revenue.
It's still mostly just me running it.
My wife helps me with the newsletter, so technically I'm not doing everything alone. 😄
I've also been building it in public on X/Twitter for years, documenting the wins, failures, experiments and random things I build.
What I learned
The biggest lesson for me is:
Don't confuse building software with building a business.
You can spend six months rewriting your frontend and end up with a nicer website but exactly the same business.
Or you can spend those six months adding another useful feature, improving distribution, talking to customers or finding another way to monetize the asset you already have.
I've had to learn to ask:
"Will this make the business better?"
before asking:
"Can I build this?"
That question has probably saved me a lot of time.
What's next?
I honestly don't have a complete roadmap.
That's another thing I like about indie projects.
The original plan was a static HTML directory with a dozen links.
I couldn't have predicted the Reddit community, the Telegram bot, the marketplace, the free tools, the SEO traffic, the different revenue streams or the AI citations.
Most of those things appeared because I kept looking at what I already had and asking:
"What else can I do with this?"
Four years later, I'm still asking the same question.
And that's probably how I'll keep building it.
