I Built an AI Job Hunting Platform for Sweden in 2 Weeks — Here's What I Learned

romina — Fri, 29 May 2026 14:34:41 +0000

When a friend told me she'd been job hunting in Sweden for six months without a single interview callback, I assumed it was a skills problem. It wasn't.

She had ten years of experience, a master's degree, and fluent English. The problem was simpler — and more frustrating: every Swedish job application expected a CV written in professional Swedish, and hers read like it had been translated from English. Because it had been.

I started asking around. Same pattern everywhere. Qualified people, locked out not because of what they knew, but because of a language and format barrier that native speakers never have to think about.

Two weeks later, I shipped JobPilot AI — a free platform that helps job seekers in Sweden find opportunities and generate professional Swedish CVs using AI.

Here's exactly what I built, how I built it, and what I'd do differently.

The Problem: Why Sweden's Job Market Is Hard for Immigrants

Sweden has over 500,000 foreign-born workers, and immigration continues to grow. But landing a job here as an international is genuinely hard — and not for the reasons you might expect.

The job board fragmentation problem. Swedish jobs are scattered across Arbetsförmedlingen (the national employment agency), LinkedIn, private job boards, company sites, and regional platforms. There's no single place to search across all of them.

The Swedish CV problem. Swedish CVs follow conventions that are notably different from English-language CVs:

Typically one page max (sometimes two for senior roles)
Formal, concise language — no personal flair or storytelling
Photo is commonly expected and normal
Personal number (personnummer) sometimes included
Specific section naming and ordering conventions
The tone is distinctly different from American or British CVs

If you're not a native speaker, you probably don't know these conventions. And if you write your CV like an English CV, Swedish hiring managers immediately notice.

This is the gap I wanted to fill.

What I Built: Feature Overview

JobPilot AI is a web app with five core features:

1. Job Search (49,000+ listings)

Aggregated from multiple Swedish sources including Arbetsförmedlingen. Users can filter by location, job type, and date. No login required to search.

2. AI-Generated Swedish CVs

This is the core feature. The user:

Pastes a job description they want to apply for
Fills in their work history and skills
Clicks generate

The AI reads the job description, identifies the key requirements and language, then writes a full Swedish-language CV tailored to that specific role. It doesn't translate your existing CV — it writes a new one optimized for the job.

3. Cover Letter Generator

Same principle as the CV generator. Takes the job description + user background and produces a personalized Swedish cover letter for that role.

4. Application Tracker (Kanban Board)

A simple kanban board: Applied → Interview → Offer → Rejected. Keeps everything in one place instead of scattered across browser tabs and spreadsheets.

5. AI Job Assistant (Chat)

A chat interface where users can ask questions like "What's a typical salary for a software engineer in Stockholm?" or "What should I include in a Swedish CV for a healthcare role?" Powered by Groq.

The Tech Stack

Frontend:  Next.js 14 with TypeScript
Backend:   Node.js REST API
Database:  PostgreSQL + Redis
AI:        Groq API (LLaMA models)
Deploy:    Vercel

Let me explain the key decisions.

Why Next.js 14?

App Router was the right choice here. I needed:

Server-side rendering for job listing pages (SEO matters for job search)
API routes for backend logic without a separate server repo
React Server Components to reduce client bundle size

The App Router's layout system made it easy to build the authenticated dashboard (tracker, CV generator) with a different shell from the public-facing job search.

Why Groq over OpenAI?

Speed. CV generation needs to feel fast — if it takes 15 seconds, users think it's broken. Groq's inference speed on LLaMA models is significantly faster than OpenAI's GPT-4o for comparable output quality.

Cost was also a factor. Since the app is free, I needed the AI layer to be cheap enough to operate sustainably. Groq's pricing at the time of building made this viable.

The tradeoff: Groq's model selection is narrower than OpenAI's. But for structured text generation (CVs, cover letters), LLaMA performs well.

PostgreSQL + Redis

PostgreSQL handles user data, saved jobs, and application tracking. Redis handles job listing cache — Arbetsförmedlingen's API has rate limits, and caching listings means we're not hitting it on every search.

TypeScript Throughout

I used TypeScript strictly on both frontend and backend. For a solo 2-week build, this felt like overhead at times — but catching type errors early saved me from subtle bugs in the AI response parsing, where the shape of what comes back from the API can vary.

The Hard Part: Prompt Engineering for Swedish CVs

This took longer than any other part of the build. Getting AI to write a CV is easy. Getting AI to write a CV that sounds like a native Swedish professional wrote it is a different problem.

What didn't work

Naive prompting:

"Write a CV in Swedish for this person applying for this job."

The output was grammatically correct Swedish but felt like a translation. Swedish HR managers would immediately notice it wasn't native.

Over-specified prompting:

"Write a formal Swedish CV. Use Swedish CV conventions. 
One page. Professional tone..."

Better, but still generic. The output didn't reflect the specific language and terminology of the job description.

What worked

The breakthrough was making the prompt bidirectional — not just describing the person, but mirroring the language of the job posting:

Analyze the job description and identify:
1. The key skills and qualifications required
2. The specific Swedish terminology used in this industry
3. The formality level of the posting

Then write a CV that uses the same terminology, addresses the key 
requirements explicitly, and matches the formality level.

This produced CVs that felt like they were written for that specific job, not just a generic Swedish CV with the candidate's details filled in.

Testing quality without being a native speaker

I'm not a native Swedish speaker, which made quality testing hard. My approach:

Used AI translation tools to back-translate the output and check for awkward phrasing
Ran outputs through Swedish grammar checkers
Asked Swedish-speaking friends to review several examples
Tested with LinkedIn job descriptions to compare output against real Swedish CVs on the platform

It's not perfect, which is why I'm actively seeking feedback from native Swedish speakers. If you're Swedish and want to test it, I'd genuinely value your input.

Architecture Overview

Here's roughly how the pieces fit together:

User (Next.js Frontend)
        │
        ▼
   Next.js API Routes
        │
        ├──► PostgreSQL (user data, saved jobs, applications)
        │
        ├──► Redis Cache (job listings, TTL: 1 hour)
        │
        └──► Groq API (CV generation, cover letters, chat)
                │
                └──► LLaMA 3.1 model

Job data flow:

Arbetsförmedlingen API
        │
        ▼
   Background sync (Node.js cron job)
        │
        ▼
   PostgreSQL (job listings table)
        │
        ▼
   Redis Cache (indexed by search terms)
        │
        ▼
   User search query → Cache hit → Response

What I'd Do Differently

1. Get a custom domain on day one

I deployed to Vercel's default subdomain. This turned out to be a problem because BetaList, one of the main startup discovery platforms I wanted to submit to, explicitly rejects submissions from free hosting subdomains. A $12/year domain would have kept that option open.

Lesson: If you're building to launch publicly, register a domain before you write a line of code.

2. Build the onboarding flow last, not first

I spent time on the profile creation flow before I had validated that people actually wanted to use the CV generator. I should have let users paste their experience inline the first time they try CV generation — only add a proper profile system once I know people are coming back.

3. Add an output review step

Currently, the AI generates the CV and shows it immediately. There's no "here are three variations, pick the best one" step. Multiple generations would dramatically improve perceived quality and give users a sense of control over the output.

4. More time on native-language testing

My prompt engineering for Swedish was done mostly in isolation. I should have found 3–5 Swedish-speaking beta testers before launch and iterated with them. The feedback loop would have been tighter.

Current Status and What's Next

The app is live and free: https://jobpilot-web-one.vercel.app

No login required to search jobs. CV generation and the tracker require a free account.

What I'm working on next:

Custom domain (to unblock BetaList and Product Hunt submissions)
Multiple CV variations per generation
Support for LinkedIn profile import instead of manual entry
Better onboarding for non-English speakers

Longer term ideas (if there's user demand):

Interview preparation feature (common Swedish interview questions by role)
Salary benchmarking for Swedish roles
Application email drafts

Try It / Feedback Wanted

🔗 https://jobpilot-web-one.vercel.app

I'd especially love to hear from:

Swedish speakers — does the generated Swedish read naturally, or does it feel off?
Anyone who has job hunted in Sweden — what's missing that would have helped you?
Other developers — any thoughts on the architecture choices, especially the Groq tradeoff?

Drop a comment below or try the tool and let me know what you think. All feedback is genuinely welcome — this is a real problem for a lot of people and I want to get the solution right.

Thanks for reading 🙏

DEV Community: romina