[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.
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
| Item | Details |
|---|---|
| Product name | love-trip |
| Development start | 2025.08 |
| Tech stack | Next.js, TypeScript, Supabase, Tour API, Naver Maps API, pnpm workspace |
| Status | In development (beta operation) |
| Core value | Unifies transport, lodging, date spots, and costs into one recommendation flow |
- Service site (service discontinued)
Key Decisions at a Glance
| Decision | Choice | Trade-off |
|---|---|---|
| Repository structure | pnpm workspace monorepo | Gives up the full independence of multi-repo, gains atomic changes to shared code |
| Data sources | Tour API primary + crawler secondary (dual) | Crawler operation burden, but fills gaps in public data and provides a fallback |
| Course generation | Rule-based scoring system (ML rejected) | Defers the precision of learning-based methods, gains explainability and instant tuning |
| Map | Naver Maps API | One more external API dependency, but prioritizes consistency of domestic place data |
| Infrastructure | Vercel + Supabase free tiers | Limited room for customization, infrastructure cost converges to 0 |
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.
| Alternative | Pros | Why I dropped it |
|---|---|---|
| Single repository, single app | Simplest | The crawler gets dragged into the web app’s build and deployment |
| Separate repositories (multi-repo) | Full independence | The cost of publishing and versioning shared types and utilities as a package is too much for a one-person setup |
| pnpm workspace monorepo | Code sharing + independent execution | None (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.
- Respect legal and ethical boundaries. I limited what is collected and how, conservatively.
- 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.
- 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.
- Real use: Use love-trip directly in actual trip planning. Not as a demo, but as a decision-making tool for a real trip.
- 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”).
- 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.
- Real-time information integration. Reflect traffic and weather data in course recommendations to make them more timely.
- Collecting user reviews. Use our own review data to reduce dependence on crawling and secure trustworthy primary data.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
Links
- Service site (service discontinued)
- Public Data Portal
- Supabase official docs
Advertisement