Skip to content
JournalTORIS / FIELD NOTES

← Blog Project notes

[Case Study] love-trip: Designing a Product That Puts Couples' Trip Planning on One Screen

A case study of love-trip: its product hypothesis, monorepo architecture, and external API dependency strategy for unifying scattered travel information.

10 min read Read the Korean original

Joohwan Yu · Founder, Full Stack Developer

Toris · Published

Contents

Q. How did a solo developer bring scattered trip-planning information onto one screen? A rule-based scoring system sits on top of dual data sources, the public Tour API and a crawler, and generates a course from just the departure, destination, and budget.

This is a technical case study of love-trip, a couples’ travel service that Toris (토리스) designs, builds, and operates. It covers everything from forming the product hypothesis to architecture decisions, external API dependency management, and the validation loop, from a one-person studio’s point of view.

Product Snapshot

ItemDetails
Product namelove-trip
Development start2025.08
Tech stackNext.js, TypeScript, Supabase, Tour API, Naver Maps API, pnpm workspace
StatusIn development (beta operation)
Core valueUnifies transport, lodging, date spots, and costs into one recommendation flow

Key Decisions at a Glance

DecisionChoiceTrade-off
Repository structurepnpm workspace monorepoGives up the full independence of multi-repo, gains atomic changes to shared code
Data sourcesTour API primary + crawler secondary (dual)Crawler operation burden, but fills gaps in public data and provides a fallback
Course generationRule-based scoring system (ML rejected)Defers the precision of learning-based methods, gains explainability and instant tuning
MapNaver Maps APIOne more external API dependency, but prioritizes consistency of domestic place data
InfrastructureVercel + Supabase free tiersLimited room for customization, infrastructure cost converges to 0

Advertisement

1. Whose Problem, and What Problem: The Product Hypothesis

When a couple plans a trip, information is badly fragmented. Place discovery lives in social media and blogs, routes in map apps, lodging in booking platforms, and budget in note apps or spreadsheets, and users have to hop between these tools and stitch the information together by hand. Three questions, “where’s a good cafe here?”, “how do we get around on this course?”, and “how much budget do we need?”, each demand an answer in a different app.

love-trip’s product hypothesis is simple.

If we can propose a trip course with movement, places, and costs calculated together from just three inputs (departure, destination, and budget), we can greatly cut a couple’s trip-planning cost in time and cognitive load.

The first users of this hypothesis were the couple the developer belongs to. When the person who builds the tool is also the person who uses it most often, that is the condition for the fastest feedback loop in a one-person studio product.

2. Constraints

For a one-person studio product, I clarify the constraints first and only then start designing.

  • People: Planning, development, and operations are all one person. A setup centered on managed services that minimize server operation burden was essential.
  • Budget: Infrastructure cost had to converge to effectively zero. That is why the stack is built from the Vercel free tier, the Supabase free tier, and a public data API (free).
  • Data: I can’t build travel place data myself. I depend on public data, the Korea Tourism Organization’s Tour API, and chose a dual strategy of filling the areas public data doesn’t cover with a crawler.
  • Schedule: Instead of launching once finished, I shipped a minimal working course recommendation flow first, then used it for real trip planning and improved it iteratively.

3. Technical Design and Trade-offs

3.1 Monorepo: Setting the Boundaries Between Web, Crawler, and Shared Logic

This product has two execution units of different natures: the Next.js web app that users touch, and the crawler that collects data periodically. They differ in deployment cadence and runtime environment, but must share data models and utilities.

There were three options.

AlternativeProsWhy I dropped it
Single repository, single appSimplestThe crawler gets dragged into the web app’s build and deployment
Separate repositories (multi-repo)Full independenceThe cost of publishing and versioning shared types and utilities as a package is too much for a one-person setup
pnpm workspace monorepoCode sharing + independent executionNone (adopted)
love-trip/
├── web/          # Next.js frontend (deployed on Vercel)
├── crawler/      # Puppeteer-based data collector (scheduled runs)
└── shared/       # Shared types and data processing utilities
# pnpm-workspace.yaml
packages:
  - 'web'
  - 'crawler'
  - 'shared'

The key criterion was “a change to shared code must reach both execution units at the same time, with no separate deployment procedure.” When the place data schema changes, the crawler’s storage logic and the web’s rendering logic have to change together, and in a monorepo this is handled atomically in a single commit. With multi-repo, the steps of publishing a new shared package version and then updating both repositories would have gotten in the way every time.

3.2 Data Pipeline: Dual Public API and Crawler

Tour API (primary source): Collects tourist attraction data from the Korea Tourism Organization’s Tour API by area code.

// Tour API call
const fetchTouristSpots = async (areaCode: string) => {
  const response = await fetch(
    `http://apis.data.go.kr/B551011/KorService1/areaBasedList1?serviceKey=${API_KEY}&numOfRows=10&pageNo=1&MobileOS=ETC&MobileApp=love-trip&arrange=A&areaCode=${areaCode}&contentTypeId=12`
  );

  const data = await response.json();
  return processTourData(data);
};

Public API responses are hard to use as they are. Field naming doesn’t match the domain and formats are inconsistent, so I made every response pass through a layer in processTourData that converts it to the internal domain model. This conversion boundary that keeps external data from flowing directly into the application’s internal types narrowed the scope of changes to this one function when the API spec later changed.

Crawler (secondary source): Place information that public data doesn’t cover is supplemented with a Puppeteer-based crawler. I settled on three principles in running the crawler.

  1. Respect legal and ethical boundaries. I limited what is collected and how, conservatively.
  2. Separate collection from service. So that a crawling failure doesn’t turn into a user-facing outage, the crawler only loads into the DB and the web app only reads from the DB.
  3. Validate before loading. To keep data corrupted by structural changes on the target site from getting in, I put data validation logic before storage.

3.3 Managing External API Dependencies

This product stands on two external dependencies, the Tour API and the Naver Maps API. External APIs can change their spec, fail, or hit rate limits at any time. The response strategy has three layers.

  • Caching: Cache results for the same area and conditions to reduce the API call volume itself. This handles rate limits and improves response speed at the same time.
  • Thorough error handling: Isolate failure points so an API failure doesn’t spread into a failure of the whole screen.
  • Alternative data source: When the primary source fails, fall back to the data in our own DB that the crawler has loaded. The dual strategy from 3.2 also works here as an availability mechanism.

3.4 Map Integration: Naver Maps

A recommended course is only convincing if it appears as a route on a map, not as a list. I chose the Naver Maps API for the consistency of domestic place data, and implemented marker and route rendering along with mobile responsiveness.

// Initialize the Naver map
useEffect(() => {
  const map = new naver.maps.Map('map', {
    center: new naver.maps.LatLng(37.5665, 126.978),
    zoom: 13
  });

  spots.forEach((spot) => {
    const marker = new naver.maps.Marker({
      position: new naver.maps.LatLng(spot.lat, spot.lng),
      map: map
    });
  });
}, []);

A map is an area where performance degrades sharply as the number of markers grows, so from the start I made it a rule to explicitly manage the creation and disposal of marker and route objects.

3.5 Course Generation Logic: A Rule-Based Scoring System

Automatic generation of “departure, destination, budget to course” is the most complex logic in this product. The variables considered are the distance between departure and destination, transport and travel time, choosing places within the budget range, and user preferences.

There was an alternative of introducing ML recommendations from the start, but I dropped it. At a stage with no user behavior data to learn from, ML is expensive and gives unexplainable results. Instead I chose a rule-based scoring system separated into stages: a pipeline that collects candidate places, scores them along distance, cost, and preference axes, and assembles the top combinations into a course within the budget constraint. The advantage of rules is that the developer can immediately explain and adjust “why this course came out,” which suited the early iteration stage of adjusting weights based on feedback.

3.6 Budget Management and 1/N Settlement

One of the real friction points of a couple’s trip is splitting costs. In implementing per-item budget entry, real-time budget calculation, and 1/N settlement, the principle I settled on is that accuracy of money calculation is non-negotiable. Since this is a feature where trust in the product collapses the moment floating-point error shows up in a settlement amount, I wrote the calculation logic as conservatively as possible and also designed a UX that tells the user immediately when the budget is exceeded.

4. Validation with Users: The Feedback Loop

The validation target for love-trip was clear: a couple actually planning a trip, and the first sample was the developer’s own couple.

I ran the feedback loop as follows.

  1. Real use: Use love-trip directly in actual trip planning. Not as a demo, but as a decision-making tool for a real trip.
  2. Recording friction: Record the points where a recommended course feels off (“you can’t actually travel this route,” “the budget calculation doesn’t match how it feels”).
  3. Reflecting in logic: Translate the recorded friction into weights and rules in the scoring system.

Some things actually changed in this loop. Redesigning course generation from simple filtering to score-based recommendation, adding a budget-exceeded alert, and showing users where the data comes from all came from friction found during use. Showing the data source in particular was a response to the user distrust of “is this information current?”, and I judged it to be the minimum mechanism for keeping trust in a product where data from multiple sources refreshes on different cycles.

Validation in the beta stage is judged by a qualitative criterion rather than quantitative metrics: “do we open this tool again for the next trip?” Separating the features that get reused (the course map, budget settlement) from those that don’t is the basis for the current roadmap priorities.

5. Operations and Current Status

  • Deployment: Automatic deployment on Vercel. The crawler refreshes data periodically through scheduled runs.
  • Data consistency: Inconsistencies from the different refresh cycles of multiple sources are managed with three layers: regular update scheduling, validation before storage, and showing the source.
  • Failure isolation: I keep a structure where neither a crawler failure nor an external API failure turns into a service outage.

The product is in development, and the next roadmap items, in priority order, are as follows.

  1. Real-time information integration. Reflect traffic and weather data in course recommendations to make them more timely.
  2. Collecting user reviews. Use our own review data to reduce dependence on crawling and secure trustworthy primary data.
  3. AI-based recommendations. Once the usage data accumulated by the rule-based system passes a threshold, consider switching to learning-based recommendations then. The current judgment is that the order must not be reversed.

6. Lessons to Reuse in the Next Product

love-trip is the product Toris has refined the longest, and it left a few principles that were carried straight over into later products.

  1. External data always passes through a conversion boundary. If you let external API responses flow directly into internal types, an external spec change spreads into edits across the whole codebase. One layer of conversion function determines the scope of maintenance.
  2. Separate collection from service starting at the execution unit. A structure where a crawler failure doesn’t become a service failure can only be secured at the architecture stage. The monorepo was the best solution for a one-person setup, keeping this separation while removing the cost of sharing code.
  3. Start recommendations with rules. ML at a stage with no data is posturing. Run the feedback loop first with a rule system that is explainable and instantly adjustable, and consider a learning-based approach after data builds up.
  4. A product where the developer is the target user is the cheapest validation environment. But to avoid generalizing from your own usage experience, you need the discipline of recording friction and making changes based on the records.
  5. Money calculation features are the last line of trust. An error in a feature that handles amounts, like settlement or budgeting, makes the polish of ten other features meaningless.

Advertisement