How We Manage 8 Active SaaS Products with a 1 Founder + 1 Manager Team

We run 8 active products with a 1 founder + 1 manager team. Bootstrapped, no VC money. (Three more — VelocityPay, FairTravels, Glassware — exist in the portfolio but are paused: internal-only, IATA-pending, and India-only ecom respectively.) And honestly? I'm still not sure the studio model is a good idea.

But it works — most days — so here's the full breakdown of how we actually pull this off at Velocity Digital Labs. The real tools, the real workflow, and the stuff that broke along the way.

We Didn't Plan This

None of this was strategic. I built ClickzProtect because I was burning cash on fake Google Ads clicks for a client project. Then I needed observability that didn't sell user data, so JustAnalytics happened. VeloCards was a weekend hack that people actually wanted. And it just... kept going.

By the time we hit 6 products, the cracks were showing. Each one had its own deployment pipeline, its own monitoring setup, its own half-written docs. I was spending more time context-switching than building anything.

The breaking point was a Tuesday late in 2025. VeloCalls went down for 4 hours because a Railway deployment failed silently, and I didn't notice because I was debugging a Cloudflare Workers issue on JustBrowser. Trials churned, the support inbox lit up. Not catastrophic. But embarrassing.

Something had to change.

First Attempt: Throw Tools at the Problem

My instinct was more tools. We tried:

Linear for project management across all products
Datadog for monitoring (which adds up fast across many products)
Sentry for error tracking
Vercel for everything frontend

The tooling bill compounded fast — separate licenses per product, per-seat costs, observability vendors that charge by hosts and ingest volume. For a small team, it was absurd.

The real issue wasn't the money, though. It was the cognitive overhead. Multiple Linear workspaces. Multiple Datadog dashboards. Multiple Sentry projects. Multiple sets of environment variables that I kept mixing up. (Yes, I once pushed a VelocityPay database string to the ClickzProtect staging environment. Nothing bad happened, but still.)

After two months, I scrapped most of it. We kept what we could replace with our own tools, and we replaced the rest with one thing: Telegram.

The Actual Stack

Here's exactly what we're running. I'm naming every tool because I wish someone had done this for me when I was figuring this out. I'm deliberately not publishing specific monthly bills — cross-product opsec, and your numbers will look different anyway.

Hosting & Infrastructure:

Railway — every product runs as a Railway project with auto-deploys from GitHub. Their DX is genuinely great, and support responds within hours. We moved off Vercel for backends because Railway's pricing is more predictable.
Cloudflare — Pro plans on the higher-traffic zones, free tier on the rest. Workers for edge logic on ClickzProtect and JustBrowser. R2 for file storage. Pages for static sites.
Neon — managed Postgres. Branching is the killer feature — every PR gets its own database branch.
Upstash — Redis and Kafka. Per-request pricing means the smaller products barely cost anything.

Development:

Claude Code — this is the big one. It's how I build, how I write docs, how I run the off-page SEO pipeline (more on that below). It's not perfect — maybe 70% of what it generates ships without major changes. The other 30% needs real rework. But for a small team managing many codebases, it's the difference between "possible" and "absolutely not."
GitHub — Teams plan. Copilot disabled (Claude Code replaces it). GitHub Actions for CI across the repos.

Monitoring & Ops (this is the part most people get wrong):

We don't use Sentry. We don't use Datadog. We don't use Better Stack. We tried all of them. What we actually use is:

JustAnalytics — our own product. It handles cookieless web analytics, event tracking, error capture, APM, session replay, and uptime monitoring across all our sites in one under-5KB script. Built it because the existing tools were either overpriced, privacy-hostile, or both. Dog-fooding it across many products has been the best QA we could ask for — every edge case shows up eventually. (More on the JustAnalytics vs Plausible vs Fathom comparison in a separate post.)
Telegram — every alert, every deploy notification, every error trace lands in a Telegram channel. One app on my phone. One notification sound. No dashboards to check. When something breaks, I know within seconds, wherever I am. Cost: $0.
Our internal status tool — a small CLI that, with one command, pulls together a management-POV daily status across all active products: signups, error rate, deploys shipped, outstanding issues, what shipped yesterday. I read it every morning with coffee. It's replaced what used to be an hour of dashboard-hopping.
JustEmails — our own email hosting product. Every inbox across every product — support@, hello@, billing@, the founder aliases, all of it — runs on JustEmails at a flat $49/year for unlimited domains and accounts. We're not paying Google Workspace or Zoho a dime. Same story as JustAnalytics: we built the thing we needed, and now we use it ourselves.

That's the entire ops stack. Four things, two of them our own products. Zero per-seat licenses.

Communication & Management:

Linear — free tier, 1 workspace. All products crammed in with labels. Ugly but functional.
Notion — free tier, just for docs.
Telegram — same as above. It's also our primary team comms channel.

The monthly bill is meaningfully smaller than what most teams running a single product on Vercel pay — that's the whole pitch of standardizing on Railway + Cloudflare + Postgres and dog-fooding our own monitoring and email products.

The Off-Page SEO Pipeline (Built in Claude Code)

One of the things I'm proudest of: we run a full off-page SEO system across all products — content generation, competitor research, outreach, distribution, monitoring, reporting — and the whole thing was built in Claude Code.

It's a multi-agent setup. Seven specialized agents (Research, Content, Outreach, Distribution, Monitor, Reporting, and an Orchestrator that coordinates them). Each agent has its own spec file. When I want a new round of content, I point the Orchestrator at the product list and it fans out the work. All content goes through a 5-layer AI detection pipeline before anything gets published. Every article, every outreach email, every directory submission is tracked.

This whole system exists because it would be impossible for a 1 founder + 1 manager team to manually run off-page SEO for many products. It's the only way the math works.

How We Actually Ship

The system works like this — and I want to be upfront that it's messy, not some beautiful architecture diagram.

Morning routine: I run the daily status command. Takes 30 seconds to pull, 5 minutes to read. I prioritize the day by revenue impact — the products generating the most revenue get attention first.

Feature work: We work in 2-week cycles, but we only actively develop 2-3 products at a time. The others run on autopilot. Right now it's ClickzProtect (big enterprise feature), VeloCards (redesign), and JustEmails (onboarding flow). The rest are in maintenance mode — bug fixes only.

The Claude Code workflow: I write a spec as a markdown file. Something like "Add team billing to VeloCards. Users need to invite teammates, share card templates, and the account owner pays. Use Stripe's multi-seat billing. Don't touch the existing individual billing flow." Then Claude Code runs with it. Generates the PR, I review, tweak, ship. A feature that'd take me 3 days solo takes about 4-5 hours this way. Not 10 minutes — that's a lie people tell on Twitter. Real features with real edge cases take real time, even with AI.

Deploys: Push to main, Railway auto-deploys, JustAnalytics confirms the health check, a Telegram message lands in my pocket. If something fails, Railway auto-rolls back and I get pinged. We don't have a staging environment for most products. (Controversial take: staging environments for early-stage SaaS are a waste of time and money. Just ship to production with feature flags and good error tracking.)

The manual side: My manager handles everything that isn't AI-buildable — partnerships, customer support escalations, invoicing, vendor management, the human side of outreach. Without that split, I'd be drowning. The clean division — I do all the AI/engineering work, he does all the manual operational work — is the only reason a 1 founder + 1 manager setup is sustainable.

Why Our Pricing Is Low

Anyone who's looked at ClickzProtect ($99/mo flat), JustEmails ($49/year flat), JustBrowser (free tier + $49/mo Pro) notices the pricing is well below what the category leaders charge. That's on purpose, and the reasoning is simple.

We vibe-coded these products. A 1 founder + 1 manager team, Claude Code, a Railway bill, and a handful of APIs. Our actual cost to run each one is low. If we priced at market — pulling per-seat numbers from the incumbents — we'd be extracting margin just because we can, not because the cost justifies it.

So we picked a different anchor: price each product in the range where it doesn't make sense for someone to go build their own version.

If you're technical enough to consider vibe-coding your own ad fraud protection, or your own analytics, or your own antidetect browser, you'll quickly hit the real costs — infra, API calls, maintenance, the edge cases you didn't think about. For most people it lands somewhere between "annoying" and "not worth it" versus just paying us. Our pricing is set right at that break-even.

That's the whole strategy. No VC-backed race to the top. No predatory upsells. We got here cheap, we'll price it cheap, and we'll make our money on volume across the portfolio instead of margin on one.

It also has a side effect I didn't plan for — it makes the products stickier. When you're paying us less than the cost of the coffee on your desk, switching to a "better" tool that costs 5x is a harder sell than it looks on paper.

What Breaks

I'd be lying if I said this runs smoothly. Here's what's gone wrong in the last 6 months:

The DevOS database migration disaster (January 2026). Neon's branching is great until you forget to merge a migration branch and your production schema is 3 migrations behind. We lost about 6 hours untangling it. My fault entirely. (Note: DevOS isn't launched yet — it's still in development — so this was internal only. But still painful.)

The Cloudflare Workers cold start problem. ClickzProtect's bot detection runs on Workers, and cold starts were adding 200-400ms of latency. For a click fraud tool, that's unacceptable — you need to block the click before the redirect happens. We ended up paying for Workers Paid and using Cron Triggers to keep the workers warm. Hacky, but it brought p95 latency well into our budget.

Claude Code generating fake API endpoints. Happened twice with Stripe integrations. It confidently wrote code using Stripe endpoints that sound real but don't exist. Now I always verify API calls against the docs before merging anything finance-related. Trust but verify — especially with money stuff.

The Telegram firehose. When we first piped everything into Telegram, I got 400+ messages a day and started ignoring it. Took a week of tuning thresholds to get it down to the ~30 meaningful alerts/day it is now. If you do this, set aggressive filters from day one.

The Shape of the Studio

A few things I'll share, deliberately qualitative — cross-product revenue specifics are opsec we don't publish, and any specific deploy-frequency or uptime number I quote would be a snapshot, not a steady state:

Active product count: 8 (ClickzProtect, VeloCards, JustAnalytics, VeloCalls, JustBrowser, JustEmails, DevOS, the parent VDL site). Three more are paused: VelocityPay (internal-only), FairTravels (IATA-pending), Glassware (India-only ecom).
Team size: 1 founder + 1 manager. The N daemons handle the rest — content pipeline, off-page SEO, distribution, monitoring, alert triage.
Funding: bootstrapped. No VC, no LPs.
Profitability: profitable from day one of each product. Margins compound when your infra is standardized and your monitoring is in-house.

Not unicorn numbers. But the studio model works when you stop pretending each product is its own company with its own ops stack.

What I'd Do Differently

If I started over? I'd build fewer products earlier and standardize harder.

The honest truth is that 3-4 of these products would be better off with full-time attention, and the rest are growing slowly because they don't get enough love. JustBrowser has a waitlist, and I haven't shipped a major update in weeks because ClickzProtect keeps demanding attention.

The specific things I'd change:

Start with the unified infra from day one. We wasted weeks migrating everything to Railway and Neon. Should've picked a stack and stuck with it.
Skip the big monitoring tools entirely. We cycled through Datadog, Sentry, and Better Stack before we landed on JustAnalytics + Telegram. Each migration lost us historical data. Should've trusted our own product earlier.
Build the daily status tool sooner. The single most-leveraged piece of internal tooling we've ever shipped. A year of "what's the state of everything right now" answered in one command.
Be explicit about paused products. DevOS is still in development with a public waitlist. FairTravels is waiting on IATA certification. Glassware is deprioritized. Clarity about what's alive and what isn't matters more than the raw portfolio count.

The multi-product approach works if you're disciplined about what gets attention and what doesn't. We're getting better. We're not there yet.

If you're thinking about running multiple SaaS products with a small team — it's doable. It's just messier than anyone's blog post (including this one) makes it sound. More posts on this on our blog.

Frequently Asked Questions

How can a 1 founder + 1 manager team realistically manage 8 SaaS products?

Standardized infrastructure (Railway + Cloudflare + Postgres for every product), shared component libraries, agentic automation for SEO and audits, and ruthless prioritization. We don't manage 8 products by working harder — we manage them by deleting work that doesn't compound. Most days, only 1-2 products get hands-on attention; the rest run on autopilot via monitoring and scheduled jobs.

What stack and tools make multi-product SaaS management possible?

Next.js 15 + TypeScript on every frontend, Postgres (Neon or Railway-hosted) on the data layer, Cloudflare for CDN/WAF/DNS uniformly, Stripe for billing, Resend for transactional email, and Claude Code as the engineering force-multiplier. The single biggest unlock is enforcing the same stack everywhere — context-switching between repos becomes nearly free.

How do you handle on-call and customer support across 8 products?

Honestly, this is where a small team breaks first. We use a single Telegram bot for ops alerts and templated support responses. For early-stage products we triage support inbox once daily. The day we hit a million-user product, we'll need to hire — there's no AI shortcut for empathetic human support yet.

What's the monthly infrastructure cost of running a multi-product studio?

Lower than people expect, because we standardized on Railway + Cloudflare + Postgres and we don't pay per-seat licenses for monitoring (JustAnalytics replaces GA4 + Sentry + Datadog + Pingdom + LogRocket across everything). The exact number depends on traffic, so we won't quote a single figure — but the discipline is what matters more than the dollar amount.

Follow the Studio

Velocity Digital Labs is a multi-product studio building 8 active SaaS products with a 1-founder + 1-manager + N-AI-agents structure. Receipts, dollar-signs, cap-table-honest. No VC platform-play — just shipping.

See the products → · Browse all VDL blog posts