Skip to content
JournalTORIS / FIELD NOTES

← Blog Project notes

[Case Study] ym_guide: Designing a Curation Product That Cuts the Cost of Finding Youth Policy Information

A technical case study of ym_guide: a question-based recommendation layer on the youth policy OPEN API, covering the product hypothesis, data processing strategy, and recommender design.

9 min read Read the Korean original

Joohwan Yu · Founder, Full Stack Developer

Toris · Published

Contents

Q. How did you pick out only the policies that apply to a user from hundreds of youth policies? I converted answers to age, residence, and income questions into conditions, and solved it with a curation pipeline that sorts by rule-based scores and weights.

This is a technical case study of ym_guide, a youth benefits curation platform that Toris designs, builds, and operates. It takes public data as raw material but solves, as a product, the “discovery cost” problem that public portals haven’t solved. It covers the data processing layer design, the question-based recommender, and the Supabase backend setup.

Product snapshot

ItemDetails
Product nameym_guide
Development started2025.12
Tech stackNext.js, TypeScript, Tailwind CSS, Supabase (PostgreSQL)
Data sourceYouth Policy OPEN API from the Online Youth Center (온라인청년센터)
Core valueCurate the financial, policy, and welfare benefits a person can receive with just a few questions

Summary of key decisions

DecisionChoiceTrade-off
Handling source dataA single transform function and a type-first designUp-front design cost; changes from API spec updates stay isolated
API call limitsLoad processed data into our own storage and serve from thereBurden of managing data refreshes (currently manual); call volume under control
Recommendation methodRule-based scores and weights (ML rejected)Defers learning-based precision; gains explainability and instant tuning
BackendSupabase (BaaS) + RLSGive up the flexibility of our own server; remove the operating cost of auth and security
Question designDecide the number and order of questions through user testingSpend on testing; find the balance between filter accuracy and completion rate

Advertisement

1. Which user, which problem: the product hypothesis

There are already plenty of policies and welfare benefits for young people, and the data is public through an open API. The problem is not supply but discovery. A young person preparing for a job after graduating from university has to go around portals scattered across agencies and check eligibility requirements one by one against their own situation to answer “what benefits can I get?” It’s not that the information is missing. The cost of picking out what applies to you is so high that people miss benefits.

I experienced this problem firsthand as a young person myself, and the product hypothesis for ym_guide came from there.

If answering just a few questions, such as age, residence, and income, can filter hundreds of policies down to the ones that apply to the user, we can dramatically cut the cost of policy discovery.

What differs from existing public portals is not the data but the interface. On top of the same data, “letting people search a policy list” and “asking users questions and curating the results” are completely different products. ym_guide bet on the latter.

2. Constraints

  • People: One person for planning, development, design, and operations. With no capacity to run my own backend server, I adopted a BaaS (Supabase).
  • Budget: Target infrastructure cost of 0 won. I built it from Vercel and Supabase free tiers and a free public API.
  • No data ownership: The source of the policy data is a government API. Not being able to control the data’s structure, quality, or refresh cycle is the biggest structural constraint of this product, and a large part of the architecture is a response to it.
  • API call limits: The public API has call limits, so a structure that hits the source API on every user request was impossible from the start.

3. Technical design and trade-offs

3.1 Data processing layer: turning data I can’t control into a form I can

The data source is the Youth Policy OPEN API of the Online Youth Center.

// API call example
const fetchPolicyData = async (params: PolicyParams) => {
  try {
    const response = await fetch(
      `https://www.youthcenter.go.kr/opi/youthPlcyList.do?openApiVlak=${API_KEY}&pageIndex=1&display=10`,
      {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json'
        }
      }
    );

    const data = await response.json();
    // Process the data
    return processPolicyData(data);
  } catch (error) {
    console.error('API call failed:', error);
    return [];
  }
};

The government API response couldn’t be used in the product as is. The structure is complex, field formats are inconsistent, and the eligibility information needed for recommendations isn’t structured. I made three design decisions in response.

  1. Fix the boundary with a single transform function. All source data goes through the processPolicyData layer and is converted into the internal domain model. Even if the API spec changes, the scope of the fix stays inside this boundary.
  2. Type-first design. I defined the TypeScript types of the internal policy model first and made the transform function guarantee them. Since the recommendation logic and UI all operate on top of these types, data format problems get caught at compile time rather than at runtime.
  3. Error handling that absorbs failure. A failure of the source API degrades gracefully to an empty result, so an uncontrollable external outage doesn’t spread into an outage of the whole product.

Because of the API call limit, I also controlled call volume with a structure that loads processed policy data into our own storage and serves from there, instead of calling the source API directly on the user request path.

3.2 Recommender: from filtering to score-based

The recommendation pipeline has four stages.

  1. Ask the user a few simple questions (age, residence, income, etc.)
  2. Convert the answers into filter conditions
  3. Extract candidates matching the conditions from the policy data
  4. Sort by priority score and display

The first implementation was simple filtering, and it failed. Listing every policy that matched the conditions gave too many or too few results, and from the user’s side it couldn’t answer “so what matters most to me?” It confirmed that filtering is a tool for exclusion, not for recommendation.

In the second implementation I redesigned it as score-based recommendation. For each policy, I score the fit with the user’s characteristics, apply different per-axis weights depending on those characteristics, and sort. I also considered ML-based recommendation but dropped it. A new service has no user behavior data to learn from, and policy recommendation is a domain where trust requires being able to explain “why this policy was recommended.” A rule-based scoring system is explainable and lets me adjust weights immediately when I get feedback, which made it the right choice for this stage.

3.3 Backend: why Supabase

As a one-person team, I asked three things of the backend: authentication, storing user data (bookmarks), and minimal operating burden. I ruled out building my own API server (Node/Express, etc.) because the operating cost of auth, security, and deployment was too much for one person, and adopted Supabase.

  • Built-in authentication. I don’t implement an auth system, including social login, myself.
  • PostgreSQL + RLS. Row Level Security enforces, at the DB level, the access control that “users only read and write their own bookmarks.” It’s the key mechanism that makes a client-to-DB direct structure safe without a separate API server.
  • Realtime features. They can be used later, when expanding features, without extra infrastructure.
// Supabase client setup
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
);

// Save a bookmark
const saveBookmark = async (policyId: string, userId: string) => {
  const { data, error } = await supabase
    .from('bookmarks')
    .insert({ policy_id: policyId, user_id: userId });

  if (error) {
    console.error('Failed to save bookmark:', error);
  }

  return data;
};

3.4 Bookmarks and My Page: giving people a reason to return

Policy discovery is not a one-time act. Some policies have application periods to wait for or eligibility to grow into, so bookmarks and a My Page that let people save policies of interest and come back were essential to the product’s retention structure. Supabase auth and the bookmark table schema design are the foundation of this feature, and I confirmed that designing the schema carefully up front determines the cost of later feature expansion.

3.5 UI/UX principles

The target is young people, so mobile-first was a precondition. I fixed four design principles.

  • A simple, intuitive interface: the shorter the question flow, the higher the completion rate
  • Mobile-first design
  • Fast loading
  • Clear information delivery: if a policy’s eligibility requirements and application method get blurred in summary, the product’s value is gone

4. Validation with users: users decided the question design

The most important design decision in this product was not technical but “what to ask the user,” and I didn’t decide that at a desk.

  • User testing of question design: I validated which questions to ask, how many, and in what order through user testing. There was a gap between the questions I thought were needed and the questions users could and would answer. More questions raise filter accuracy but also raise drop-off, and I found the balance point of that trade-off through testing.
  • Collecting feedback on recommendation results: I ran a loop of collecting cases where recommendations didn’t match user expectations and reflecting them in the score weights. The “filtering to score-based” redesign in 3.2 was itself the biggest change this feedback loop produced.
  • Developer = target user: I, a young person myself, was the first person to validate it. Whether the policies I knew about were recommended correctly from my own inputs served as a smoke test of the recommendation logic.

What I confirmed in this process is that the quality of a curation product depends first on the quality of input design (the questions), before the sophistication of the algorithm. A sophisticated algorithm on top of the wrong questions gives precisely wrong answers.

5. Operations and current state

  • Deployment: Vercel automatic deployment kept the operating burden minimal.
  • Data refresh: The biggest operational debt is that refreshing policy data is currently a manual process. Policy information is data with an expiry, so automating the refresh is the top priority on the technical roadmap.
  • Cost: It runs with no infrastructure cost on a combination of free tiers.

The roadmap, in priority order, is as follows.

  1. Automate policy data refresh. Switch from manual updates to scheduled automatic refresh. It’s a reliability issue, so it’s the top priority.
  2. Build a user feedback system into the product. Collect feedback on recommendation results inside the product so the weight-improvement loop runs continuously.
  3. Advance the recommendation algorithm. Consider ML-based recommendation once feedback data has accumulated. Accumulating data comes first.

6. Lessons to reuse in the next product

  1. The competitiveness of a public-data product is the interface, not the data. Even on the same API, “letting people search” and “asking questions and curating” are different products. Without data ownership, you have to create value by cutting discovery cost.
  2. Contain data you can’t control with a transform boundary and types. The less you control the source data’s quality, structure, and refresh, the more the internal domain model and a single transform layer are worth.
  3. Filtering is not recommendation. Between listing what matches the conditions and showing it in the order that matters to the user, you need a design of scoring and weights.
  4. Question design belongs to user testing. Every item in an input form is a product decision that determines completion rate and recommendation quality at once, and it can’t be decided by developer intuition.
  5. For a one-person team, BaaS + RLS structurally removes backend operating cost. Supabase’s RLS was the key to making an architecture without an API server secure, and this pattern became the default in later products.
  6. Always record manual operating processes as debt. “Manual for now” is a valid choice that brings launch forward, but in a product with data that expires, reliability risk keeps piling up until it’s automated.

Advertisement