Skip to content
JournalTORIS / FIELD NOTES

← Blog Project notes

How Toris Builds Products: The Development Workflow of a One-Person Studio

The tools, automation, and quality gates Toris uses from planning to operations: a standard stack, type checks, CI tests, and Sentry stand in for reviewers, and the trade-offs involved.

7 min read Read the Korean original

Joohwan Yu · Founder, Full Stack Developer

Toris · Published

Contents

Q. How does a one-person studio with no reviewers keep quality up?

A standard stack removes the cost of choosing, and type checks, automated CI tests, and Sentry monitoring act as quality gates, filling the reviewer’s seat with automation.

Toris is a one-person software studio. The planner, designer, frontend developer, backend developer, and infrastructure owner are all one person, so the workflow is the team. Process and automation have to stand in for the people we lack, and if the criteria for which tools we use and why get blurry, quality wobbles immediately.

This post is a public document that lays out how Toris builds a product from planning to operations, which tools and quality gates we put at each stage, and what the trade-offs of those choices are. Both our own products and client projects run on the same skeleton.

The Whole Pipeline

Planning → Design → Development → Quality gates → Deployment → Operations/feedback → Back to planning

There are five stages, but in practice it’s a cycle. Feedback collected from operations becomes the input for the next round of planning, and I think keeping this cycle short is how a one-person studio offsets its disadvantage in scale.

1. Planning — Documents Are the First Deliverable

Before opening any code, I produce three things as documents first.

  1. Requirements analysis

    • Feature spec: State what we will build and what we won’t. The “won’t build” list matters especially. In a one-person studio, a failure to manage scope is a failure of the schedule.
    • Tech stack selection: The default is an already-proven stack (see below), and I write down a reason only when I deviate.
    • Architecture design: Start at the level of a single diagram. Avoid over-design early on.
  2. Initial project setup

    • Create the repository and set up the development environment
    • Set up the CI/CD pipeline at the time of the first commit. CI that you attach later ends up never getting attached.

The trade-off here: time spent on documentation slows down development speed in the short term. I keep doing it anyway because the more you work alone, the more “me three months from now” is effectively a different teammate, and documents are the only means of handing work over to that person.

Advertisement

2. The Standard Stack — Fewer Choices Means Speed

Toris’s default stack is as follows.

Frontend

Planning → Design system → Component development → State management → Testing → Deployment
  • React / Next.js — Frontend framework
  • TypeScript — Type safety
  • Tailwind CSS — Styling
  • Jest / React Testing Library — Testing

Backend

API design → Database design → Server implementation → Testing → Deployment
  • Node.js / Express — Server
  • PostgreSQL / MongoDB — Chosen by the nature of the data (PostgreSQL when relationships are clear, MongoDB when the schema is fluid)
  • Jest / Supertest — API testing
  • Docker — Containerization

DevOps

Code commit → CI pipeline → Automated tests → Deployment → Monitoring
  • GitHub Actions — CI/CD
  • Vercel / AWS — Vercel for the frontend, AWS for workloads that need infrastructure control
  • Sentry — Error tracking

Why this combination — the trade-offs

  • Unifying the frontend and backend on TypeScript/JavaScript gives up the best tool for each language in exchange for eliminating context-switching costs. In a setup where one person moves between frontend, backend, and infrastructure in a single day, the benefit of a single language is bigger.
  • Using Vercel as the default deployment target gives up some infrastructure freedom and buys a lighter operations burden. It’s the result of admitting the constraint that there’s no time to spend managing servers, and we go to AWS only when there’s a requirement Vercel can’t handle (long-running jobs, fine-grained network control, and so on).
  • Tailwind CSS ties the design system tightly to the code, at the cost of verbose markup. When you have to keep the UI consistent without a separate designer, the constraints of utility classes actually act as design guardrails.

There is one core principle: we don’t pick a new stack for each project. The time spent evaluating new tools is the most expensive cost in a one-person studio, and when we deviate from the standard stack, we leave the reason in a document.

3. Development — Task Management and Branch Strategy

Issue management

  • I track all work with GitHub Issues. The reason I don’t have a separate project management tool is simple: code and issues have to live in the same place for management to hold up even when working alone.
  • I state priorities and record progress in the issue. The issue becomes both the work log and the material for retrospectives.

Branch strategy

  • I create a branch per feature and merge into the default branch through a PR.
  • Why I make PRs even when working alone: before a PR is a review request, it’s a record of a unit of change. Even in a self-review, quite a few mistakes get caught while looking at the diff once more, and it becomes the unit for tracing “why was this change made” later.

Development order

  1. Frontend — Component design and implementation, state management, polishing UI/UX
  2. Backend — API design and implementation, database design, authentication/authorization
  3. Integration — Unit tests, integration tests, and E2E tests when needed

4. Quality Gates — When There Are No People, the Gates Block

In a setup with no reviewers, the only way to keep quality up is automated gates. Toris’s gates apply in this order.

  1. Type checking — TypeScript is the first reviewer.
  2. Automated tests — Unit tests (Jest/RTL) and API tests (Jest/Supertest) run in CI. If they don’t pass, the change isn’t merged.
  3. CI pipeline — GitHub Actions runs the build and tests on every commit.
  4. Post-deployment monitoring — Sentry error tracking and performance monitoring serve as the gate after deployment.

My stance on test coverage is also a trade-off. Writing tests for all code is unrealistic with one person’s resources, so I concentrate tests on paths that are costly when broken (payments, authentication, data mutation logic, public APIs) and go thin on UI details.

5. Deployment and Operations

Deployment automation

  • Docker containerization removes differences between environments.
  • Cloud deployment (Vercel, AWS) is connected to CI, so a merge becomes a deployment candidate.
  • The principle is to leave no manual deployment procedure. “A deploy order only I know” is the most dangerous single point of failure in a one-person studio.

Operations optimization

  • Performance monitoring — Check performance metrics after deployment and track regressions.
  • Error tracking — Collect runtime errors with Sentry. The goal is to know before users report it.
  • Collecting user feedback — Feedback goes into the next cycle as planning input.

Client Projects — Building Trust with Weekly Updates

Our own products and client projects share the same development skeleton, but client work has one more layer: weekly updates.

The biggest worry of a client who hands work to a one-person studio is “not being able to see progress.” So Toris keeps the following on a weekly rhythm.

  • I summarize and share what I did this week / what I’ll do next week / what’s blocked. The key is not hiding what’s blocked. The later you report a problem, the more expensive it gets.
  • I show progress not with words but with things you can see. I prepare visuals such as a deployed preview URL, screenshots and demo videos, and architecture diagrams.
  • Scope changes aren’t handled verbally; I leave them in a document (an issue). It’s a device that protects both sides.

The trade-off of this approach is also clear. The time spent each week summarizing and sharing comes out of development time. I keep doing it anyway because the cost of recovering a project where trust has broken down is always bigger than the cost of a weekly update.

Documentation and Knowledge Management

  • README — Every repository guarantees, through its README, the path from clone to running.
  • API documentation — For a public API, the documentation is the interface.
  • Tech blog — I write up project retrospectives, problem-solving processes, and what I’ve learned on this blog. The process of writing is itself a check on the design, and the public record is also the studio’s portfolio.

Continuous Learning — The Studio’s R&D

In a one-person studio, learning isn’t a perk; it’s survival. When evaluating a new technology, I follow this order.

  1. Foundations — Read the official docs first, and confirm the basics with a tutorial.
  2. Practice project — Apply it to a toy project and get a real feel for it by refactoring. This is a buffer stage so that unproven technology doesn’t go straight into a client project.
  3. Going deeper and giving back — Learn advanced patterns and write them up as open-source contributions or blog posts.

Only technologies that survive this process become candidates for the standard stack.

Summary

Here’s Toris’s workflow in one sentence.

Since there’s only one person, we automate everything that repeats, and we put everything that requires judgment into documents.

  • A standard stack removes the cost of choosing
  • CI, tests, and monitoring fill the reviewer’s seat
  • Weekly updates build trust with clients
  • A short cycle in which operational feedback returns to the next round of planning

This structure isn’t finished; it’s still being refined, and I plan to update this document whenever it changes.

Reference Resources

Advertisement