DEV Community: sweety

The One Line That Deleted All My JSON Parsing Code

sweety — Mon, 29 Jun 2026 12:32:49 +0000

I Was Stuck for Hours. Then I Found `response_schema`.

A real story from building K-Trust — my AI merchant compliance tool

Okay so let me be honest.

When I started building K-Trust, I thought the hard part would be the AI logic. The prompts, the scoring rubric, the compliance summary. That stuff.

I did not expect to spend hours fighting with JSON.

The Problem I Kept Running Into

The idea behind K-Trust was simple — send raw merchant data to Gemini, get back a structured risk report. Trust score, risk level, legal status, summary. Clean. Predictable.

Except it wasn't.

My first approach was the obvious one — just tell Gemini what to return:

prompt = """
Analyze this merchant and return a JSON with:
- trust_score (int)
- risk_level (string)
- legal_status (boolean)
- summary (string)
"""

Sometimes it worked perfectly. Sometimes Gemini returned this:

Sure! Here's the compliance report:
```json
{
  "trust_score": 87,
  ...
}
```

And my json.loads() would crash.

So I added .strip(). Then .replace("`json", ""). Then a whole try/except block. Then another one. I was writing more parsing code than actual feature code and it still broke randomly.

I remember staring at my terminal thinking — there has to be a better way.

The Rabbit Hole That Saved Me

I went back to the Google Gemini API docs — properly this time, not just skimming. And buried in the structured output section, I found something I had completely missed:

You can pass a Pydantic model as response_schema to enforce the exact output shape.

Wait. You can enforce it? Not just ask nicely?

I also found this mentioned in the Google GenAI Python SDK docs with actual code examples. I read through the Pydantic BaseModel docs to understand how to define the schema properly.

And then I tried it.

The Moment Everything Clicked

Step 1 — I defined exactly what I wanted Gemini to return

python
from pydantic import BaseModel

class GeminiReport(BaseModel):
trust_score: int
risk_level: str
risk_tags: list[str]
legal_status: bool
financial_risk: bool
sentiment_score: bool
executive_stability: bool
summary: str

Step 2 — I passed it directly to Gemini as `response_schema`

python
ai_response = client.models.generate_content(
model="gemini-2.5-flash",
contents=prompt,
config=types.GenerateContentConfig(
response_mime_type="application/json",
response_schema=GeminiReport, # Gemini MUST match this shape
),
)

structured_data = json.loads(ai_response.text)

And that was it.

No markdown stripping. No defensive parsing. No random crashes at 2am.

structured_data came back perfectly typed every single time. trust_score was always an int. legal_status was always a bool. The fields were always exactly what I defined.

I literally said "oh" out loud when it worked the first time.

What My Final K-Trust Endpoint Looks Like

python
@app.post("/audit")
async def run_audit(request: AuditRequest):
# 1. Look up merchant data
merchant = MARKET_DB["merchants"].get(request.merchant_id)
if not merchant:
raise HTTPException(status_code=404, detail="Merchant not found.")

# 2. Build prompt with raw business data
raw = merchant["raw_data"]
prompt = f"""

Audit this merchant and return a compliance report.
Company: {merchant["company_name"]}
LEGAL RECORDS: {chr(10).join(raw["legal_records"])}
FINANCIAL SIGNALS: {chr(10).join(raw["financial_signals"])}
"""

# 3. Gemini returns perfectly structured data — every time
ai_response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=prompt,
    config=types.GenerateContentConfig(
        response_mime_type="application/json",
        response_schema=GeminiReport,
    ),
)

structured_data = json.loads(ai_response.text)
return {"status": "success", "data": structured_data}

Clean. No drama.

What I Learned

Before finding this, I thought structured LLM output was always going to be messy. That defensive parsing was just... the cost of working with AI.

It's not. You just need the right tool.

The messy way	The clean way
Hope the LLM follows your prompt	Enforce the exact output shape
Write layers of parsing code	Just `json.loads()` and done
Random crashes in production	Consistent output every time
Different field names each run	Exact Pydantic types guaranteed

If you're building anything with Gemini that needs structured output — skip the struggle I went through. Go read the structured output docs first. I wish I had.

Resources That Helped Me

📖 Gemini Structured Output Docs — this is the one that changed everything
📖 Google GenAI Python SDK — real code examples here
📖 Pydantic BaseModel Docs — for defining your schema properly
🔗 K-Trust Live Demo — see the full thing in action

- 📦 K-Trust GitHub — full source code

Written by SweetyCodes (Subhashree Behera) — AI & Full-Stack Developer *
Currently building AI-powered web apps and learning Korean *

I Built an AI That Researches How Your Target Company Interviews — Then Simulates It

sweety — Mon, 08 Jun 2026 13:58:21 +0000

canonical_url: https://velog.io/@sweety_jh223/InterviewLense
🔗 Live: https://interview-lense.vercel.app
📦 GitHub: https://github.com/sweety-HJH223/InterviewLense

The Problem

Most interview prep tools give you the same generic questions regardless of where you're applying. "Tell me about yourself." "What's your greatest weakness?"

It doesn't matter if you're interviewing at Google or a 10-person startup — you get the same list. Most simulators are "one-size-fits-all": they ignore your unique career history and fail to provide the real-world feedback needed to actually pass a high-stakes interview at a top-tier tech firm.

But interviews are NOT the same across companies:

Google wants reasoning processes over perfect answers.
Amazon scores everything against 16 Leadership Principles.
Kakao/Naver expect specific Korean-market-scale product thinking.
Toss focuses on speed of execution.

I wanted a tool that actually knows this. So I built InterviewLens.

The Solution

InterviewLens is an AI-powered simulation engine that:

Takes any company name and role.
Researches that specific company's hiring culture in real-time.
NEW — Resume Alignment: Upload your PDF or paste your resume, and the AI identifies the specific gaps between your experience and the company's requirements.
Simulates the interview in that company's actual style.
Evaluates your answers against the company's specific criteria.
Maintains a long-term "memory" of your growth across sessions.

The 3-Agent AI Architecture

The heart of InterviewLens is a 3-agent orchestration pipeline built with Google Gemini.

Agent A — The Researcher

Agent A scans for hiring focus, round structure, and cultural values.

The "Context Engine": It doesn't just research the company — it accepts your resume/PDF data and performs a gap analysis between your background and the company's requirements, making the research personalized from the start.

Agent B — The Interviewer

Agent B receives the intelligence from Agent A and becomes that company's actual interviewer.

Contextual Interaction: Because it receives your resume context, Agent B doesn't ask generic questions. It asks: "You worked on [X] project in your resume — how would you scale that for the traffic [Company] handles?"

Agent C — The Evaluator

After you finish, Agent C acts as a "Hiring Committee."

Strict Scoring: It penalizes generic "template" answers and rewards candidates who leverage their specific background effectively.

Technical Challenges & My Solutions

1. The performance bottleneck

Initially, researching companies via AI took 10+ seconds, often leading to "Request Timed Out" errors.

My solution: I implemented a Redis-like caching layer using Firebase Firestore. Once a company/role is researched once, subsequent searches are near-instant — solving both latency and quota exhaustion effectively.

2. Handling unstructured PDF data

Users need resume-tailored questions, but parsing PDFs is messy.

My solution: I leveraged Gemini 1.5 Flash's multi-modal capability to directly parse PDF resumes, extracting structured data that the interview agent uses for context-aware follow-up questions — no external PDF libraries needed.

3. Agentic complexity

Coordinating three distinct AI agents (Researcher, Interviewer, Evaluator) led to prompt injection and state management issues.

My solution: I built a strict orchestration layer that forces a JSON-only output schema. By forcing the models to adhere to a predefined JSON structure, I eliminated parsing failures and enabled smooth state sharing between all three agents.

Google Tech Stack

Tool	Purpose
🤖 Google Gemini 1.5 Flash	Powers all three agents — research, interview simulation, and evaluation
🔥 Firebase Firestore	Session storage, long-term candidate memory, and research cache
☁️ Vercel / Next.js	High-performance, real-time deployment of the simulation interface

What I Learned

Multi-agent systems are more powerful than single-prompt approaches. By separating Research, Interviewing, and Evaluation, each agent maintains a clear focus.

The most challenging part was Resume Alignment. Simply "sending the resume" wasn't enough — I had to engineer the prompts to force the AI to compare the candidate's past with the company's future needs. This bridge is what transforms a standard chatbot into an actual coaching tool.

Try It

🔗 Live: https://interview-lense.vercel.app
📦 GitHub: https://github.com/sweety-HJH223/InterviewLense

Built for Google Gen AI Academy APAC 2026 — Meet the Builders Campaign.
Subhashree Behera | SweetyCodes — AI & Full Stack Developer, India

Hello DEV! 👋 Full-Stack Dev diving into AI Orchestration

sweety — Sun, 24 May 2026 04:27:38 +0000

Hey everyone! 👋

I'm super excited to finally join the DEV community. I’ve been browsing articles here for a while, but I decided it was time to step out of the shadows, start documenting my build logs, and connect with fellow developers.

🛠️ What I'm working with:

Frontend: Next.js, React, Tailwind CSS
Backend & Data: Python, Django
The New Frontier: API & Automated AI Orchestration (AI Agents)

I’m here to learn from the community, swap war stories about debugging, and meet other devs who love building clean, responsive applications.

let’s connect! What are you currently building this week?

DEV Community: sweety

The One Line That Deleted All My JSON Parsing Code

I Was Stuck for Hours. Then I Found response_schema.

The Problem I Kept Running Into

The Rabbit Hole That Saved Me

The Moment Everything Clicked

Step 1 — I defined exactly what I wanted Gemini to return

Step 2 — I passed it directly to Gemini as response_schema

What My Final K-Trust Endpoint Looks Like

What I Learned

Resources That Helped Me

- 📦 K-Trust GitHub — full source code

I Built an AI That Researches How Your Target Company Interviews — Then Simulates It

The Problem

The Solution

The 3-Agent AI Architecture

Agent A — The Researcher

Agent B — The Interviewer

Agent C — The Evaluator

Technical Challenges & My Solutions

1. The performance bottleneck

2. Handling unstructured PDF data

3. Agentic complexity

Google Tech Stack

What I Learned

Try It

Hello DEV! 👋 Full-Stack Dev diving into AI Orchestration

🛠️ What I'm working with:

I Was Stuck for Hours. Then I Found `response_schema`.

Step 2 — I passed it directly to Gemini as `response_schema`