Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
A solo business built by stacking data in Notion, running automations with Zapier or Make, and putting a wrapper on it with Webflow or Bubble has obvious limitations. Even a slight spike in traffic triggers API rate limit warnings. With data fragmented across different tools, management becomes a mess, while the monthly subscription bills easily exceed 200,000 won.
Without a background in computer science, making money by assembling other people's services like building blocks is more exhausting than you might think. Behind the flashy integration interfaces, all that remains are webhook errors waiting to explode and recurring payments for foreign tools. The only way to break this treadmill is to set up a server of your own and run your automations and code directly on it.
Running just a few multi-step tasks in Zapier quickly exhausts the $73-a-month Pro plan. Make also sees its fees skyrocket as the number of operations increases. In contrast, if you host n8n, an open-source workflow tool, directly on your personal server using a Docker container, the execution limit itself disappears.
Hetzner's CX22 instance costs just €3.79 a month as of 2026 (approximately 6,000 won). Since it provides 2 vCPUs and 4GB of RAM, it has more than enough specs to serve as a backend for a solo business. Install Docker on an Ubuntu 24.04 LTS environment, and enter just a single command line: docker run -d --name n8n -p 5678:5678 -v ~/.n8n:/home/node/.n8n n8nio/n8n, and your own automation server is up and running.
For the database, instead of heavy MySQL, hook up lightweight SQLite or container-based PostgreSQL 16.
These tasks, which previously stuttered while routing through three or four paid SaaS products, are completed within a single Linux instance via internal loopback communication. The fixed monthly automation subscription fee of 150,000 won drops down to a server cost of 6,000 won.
There is one area where non-developers have a clear advantage over developer-founders: the fact that single-logic code to solve a problem can now be generated in just 10 minutes by throwing a few prompts at AI models like Cursor or Claude 3.7 Sonnet. The challenge is moving beyond the stage of running this script locally in your terminal alone, and turning it into a web service that charges users.
If you ask an outsourcing agency for a quote, they will ask for at least 5 million won and a month of development time. There is no need for that at all. By using the Python FastAPI framework, you can package a single-function script into a paid subscription service in three days.
`python
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import jwt
app = FastAPI()
security = HTTPBearer()
SECRET_KEY = "your-jwt-secret"
def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
try:
payload = jwt.decode(credentials.credentials, SECRET_KEY, algorithms=["HS256"])
return payload["sub"]
except jwt.PyJWTError:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="인증 실패")
@app.post("/api/v1/run-service")
def run_service(user_id: str = Depends(verify_token)):
# AI가 작성한 메인 비즈니스 로직 실행
return {"status": "success", "user": user_id}
`
Attaching Stripe payment webhooks to this structure completes the billing system. When a customer finishes payment on the Stripe checkout page, the checkout.session.completed event is received by the FastAPI endpoint.
As soon as the webhook is received, a 30-day JWT token is issued using the user's email as the identifier and sent via email. Instead of a complex React setup, the frontend is kept lightweight using a single HTML file with the Tailwind CSS CDN. Without spending a single won on outsourcing, an independent software product generating $29 a month in subscription revenue begins running within a week.
When running your own server, the scariest moments are waking up to find your site down or your hard drive messed up. For a solo founder without an engineering team, complex monitoring tools like Kubernetes or Datadog are a luxury. Two lightweight and robust open-source tools are more than enough.
Server health monitoring is handled by spinning up an Uptime Kuma container. It is a lightweight daemon that consumes just about 100MB of memory, sending HTTP requests to the service URL every 60 seconds to check the response code. If a 500 error or timeout occurs, it immediately sends a notification to my smartphone via the Telegram Bot API. It takes less than a minute to notice even if a disruption occurs.
Data loss is prevented using a 3-line shell script registered in a cron job. Every day at 4 AM, the database dump file is compressed and sent to Cloudflare's R2 storage.
`bash
#!/bin/bash
DATE=(date +%Y%m%d)
sqlite3 /data/production.db ".backup '/backup/db_DATE.sqlar'"
rclone copy /backup/db_$DATE.sqlar r2:my-backup-bucket/
find /backup/ -type f -mtime +7 -delete
`
Cloudflare R2 costs 0 won for storage up to 10GB per month and does not charge outbound traffic fees. Local backup files older than 7 days are automatically deleted so they don't consume server space. Even if the server is completely wiped out, downloading a single backup to a new instance and starting Docker allows you to restore the service within 20 minutes. A business run directly on your own server, without having to care about someone else's platform, finally gets on track.
