Integrating OpenAI Is Not Enough

The hardest part of building an AI-powered feature is rarely calling the OpenAI API.

The real challenge is designing a reliable workflow around the model.

While building Joby, I wanted candidates to be able to generate a CV tailored to a specific job opportunity.

On paper, the process looked straightforward:

Job posting → Prompt → Tailored CV

But this first approach was too fragile to become a dependable product feature.

Why a single prompt was not enough

Job postings do not follow a consistent structure.

Some clearly describe the required skills, responsibilities, and expected experience. Others mix those details with marketing copy, navigation elements, recommendations, and unrelated content.

Candidate information creates a similar problem.

When everything is sent to the model as one long block of unstructured text, it becomes harder to control what is selected, rewritten, or omitted.

This initial approach introduced several risks:

  • important details could be ignored;
  • experience could be rewritten too freely;
  • the output format could vary between generations;
  • manual editing remained difficult;
  • automated validation was limited.

The problem was not just the prompt.

The problem was the entire pipeline.

Structuring the data before using the model

I decided to split CV generation into several distinct stages.

1. Extract the important information from the job posting

The posting is first converted into structured data.

The system attempts to identify information such as:

  • job title;
  • company;
  • main responsibilities;
  • required skills;
  • mentioned technologies;
  • expected experience level;
  • posting language.

This step removes unnecessary noise before the model is called.

2. Use a structured candidate profile

Candidate information is not taken from an arbitrary CV file for every generation.

Joby uses a structured candidate profile containing work experience, skills, education, projects, and other relevant professional information.

That profile becomes the source of truth.

The model can select and rewrite relevant information, but it should not invent experience that does not exist.

3. Generate a first draft

OpenAI is then used to connect the job requirements with the candidate’s background.

The model does not simply receive two large blocks of text.

It receives prepared context that is more consistent and easier to control.

Its role is to produce a strong first draft, not to make the final decision on behalf of the candidate.

4. Keep the user in control

The generated CV remains fully editable.

The candidate can refine the wording, reorganize sections, and adjust the level of detail. They can also work directly with the LaTeX source when they need precise control over the final layout.

This was an essential product decision.

AI should accelerate the work without taking ownership away from the candidate.

The final pipeline

The workflow now looks more like this:

Raw job posting
    ↓
Extraction and cleanup
    ↓
Structured job data
    ↓
Structured candidate profile
    ↓
OpenAI generation
    ↓
Validation
    ↓
User editing
    ↓
Final CV

Each stage reduces a different type of uncertainty.

The model still matters, but it becomes one component inside a larger system.

AI is a component, not the product

This experience changed the way I think about features built with language models.

A good integration does not depend only on a well-written prompt.

It also depends on data quality, output validation, error handling, editing experience, and how much control remains with the user.

The important question is not only:

Which model should we use?

We also need to ask:

What happens before and after the model call?

That is often where the real product value is created.

What I learned

The main lesson is simple:

An AI feature is first an architecture and user-experience problem.

The model can generate content.

But the surrounding system must ensure that the content is relevant, verifiable, editable, and genuinely useful.

What about you?

What has been the hardest part of integrating AI into your product?

Prompt design, data quality, response validation, or user experience?

I would love to hear about your experience.

This article is part of “Behind Joby,” a series about the technical decisions involved in building a modern SaaS product.

Next article: why I chose Convex to build Joby’s backend.