Zoo-keeper on the side: How a house full of animals led to my first real SaaS

My X bio says "Zoo-keeper on the side." It's not a joke. At any given moment, I'm sharing my house with three horses, two dogs, a cat, and a Russian steppe tortoise who was smuggled into Sweden sometime in the 1940s and has outlived most of the people who remember why.

This isn't a lifestyle I planned. It's one that accumulated, the way animals tend to when you're the kind of person who can't drive past a shelter without wondering if anyone in there needs a home. Turns out, someone always does.

It's also, unexpectedly, how I ended up building my first real SaaS product.

The menagerie

Let me introduce the cast. Not because it's relevant to software development, but because you can't understand why I built what I built without understanding who I built it for.

The horses came first. Olius is a Swedish Ardennes built like a small tank. Niter is a Gotland pony with more personality than horses twice his size. We got them together when their previous owner needed major surgery and his wife couldn't manage them alone. We originally only wanted Olius, but he and Niter have been inseparable since they were foals. Splitting them up wasn't an option.

Olius - the small tank

Niter - more personality than horses twice his size

Then there's Evidence - Eve for short - a nine-year-old Swedish Standardbred whose racing career ended without any notable earnings. We bought him when his days on the track were over. He treats every training session like a negotiation, which might explain the career trajectory.

Three horses is already more than most people consider reasonable. They're wonderful, but they're also walking spreadsheets of logistics: training schedules, vet visits, farrier appointments, vaccination records, feeding plans, health notes. Multiply that by three and you have a part-time administrative job that nobody warned you about.

Then there's Roberto, our three-legged dog. We brought him home from a shelter in Spain two years ago. His breed is officially unknown - our best guess is a long-legged Transylvanian Hound mix, but that's never stopped us from loving him for who he is. He's missing a front leg and absolutely none of the attitude. He runs faster than Nicco, our other dog, who has the full set, which I think embarrasses him.

Roberto - missing a leg, none of the attitude

Nicco - has the full set, still slower

The cat, Sam, showed up on a parking lot in our village about a year and a half ago. He was maybe four weeks old, alone, with a respiratory infection bad enough that he probably had days left without intervention. When I picked him up, he fit entirely on my phone. Not next to it - on it. An iPhone 14 was his whole world. For the next three weeks, we were at the vet every single day - injections, medication, monitoring his breathing. It was touch and go for a while. Now he's a healthy, opinionated adult who acts like he owns the place. He's not wrong.

And then there's Chicco. Chicco is a Russian steppe tortoise, approximately 80 years old, with a history that sounds made up. According to the previous owners, he was smuggled into Sweden during the 1940s. We took him in when they moved to an apartment and couldn't keep him anymore.

Chicco hates captivity. We built him a nice terrarium - proper lighting, correct humidity, the works. He wanted nothing to do with it. So now he roams the house freely, appearing in random rooms like a very slow, judgmental ghost. In summer, he has an outdoor enclosure he actually tolerates. I think he just objects to walls on principle. After 80 years, you earn the right to be stubborn.

Tortoises are more social than people think. Something I never would have believed until I saw it: Chicco knows his name. Call him, and after a few minutes, a small suspicious face will peer around a corner, wondering what you want. He's not fast about it, but he shows up. Every time.

The spreadsheet that broke

For years, I managed everything with spreadsheets. Horse vaccinations in one sheet, training logs in another, vet records scattered across various Google Docs that I could never find when I actually needed them. It worked, barely, the way duct tape works - functional until the exact moment it matters.

The breaking point came when I missed a vaccination deadline. Not by much, but enough to be annoying. I'd logged it, I was sure I had, but the spreadsheet had become such a mess of tabs and conditional formatting that finding anything required archaeological patience.

I thought: there has to be an app for this. Something designed for stable management, with proper scheduling and reminders and a sensible way to track multiple horses.

There wasn't. Or rather, there was, but everything I found was either abandoned, overpriced, or designed by people who had clearly never touched a horse. The UX was universally terrible - the kind of enterprise software that makes you fill out seventeen fields to log a simple vet visit.

So in April 2025, I built my own.

The MVP that was just for me

The first version of Horsemate was embarrassingly simple. It could track horses, log activities, and remind me about upcoming events. That's it. No multi-user support, no fancy features, just a slightly better spreadsheet with a nicer interface.

I chose Next.js because I was already comfortable with React and wanted the flexibility of both static and dynamic rendering. For a solo project where I'd be the only developer, framework familiarity mattered more than theoretical performance gains from something newer.

For the UI, I use shadcn/ui. It's unprecedented when it comes to quickly building functional, good-looking components. Copy, paste, own the code, move on. No fighting with library updates or style overrides. I use it in every project now - including this very site you're reading. It's that good.

Hosting went to Vercel for the obvious reason: it just works. Push to main, deployment happens, SSL certificates renew themselves, I never have to think about servers. When you're building something in your spare time while also managing an actual zoo, "never think about it" is a feature worth paying for.

For email, I use Resend in every project now. Weather warnings, vaccination reminders, team invitations - all of it goes through Resend. The API is clean, the deliverability is solid, and I've never had to debug why emails aren't arriving. Same philosophy as Vercel: it works, so I can focus on building features instead of fighting infrastructure.

The database choice was more interesting. I went with Supabase, partly for the generous free tier, but mostly for the Row Level Security.

-- Real RLS policy from health_entries table
-- All stable members can view, but only owners/helpers can modify

CREATE POLICY "stable_members_can_view_health_entries"
  ON public.health_entries FOR SELECT
  USING (
    EXISTS (
      SELECT 1 FROM public.stable_members
      WHERE stable_members.stable_id = health_entries.stable_id
      AND stable_members.user_id = auth.uid()
    )
  );

CREATE POLICY "managers_can_create_health_entries"
  ON public.health_entries FOR INSERT
  WITH CHECK (
    EXISTS (
      SELECT 1 FROM public.stable_members
      WHERE stable_members.stable_id = health_entries.stable_id
      AND stable_members.user_id = auth.uid()
      AND stable_members.role IN ('owner', 'helper')
    )
  );

When you're building something that handles health records, vaccination schedules, and medication logs for people's animals, security isn't optional. RLS lets me define access rules at the database level - even if I screw up the application code, the database itself refuses to leak data between stables.

Every table has policies like this. Horses, health entries, tasks, feed logs - all scoped to stable membership, with role-based restrictions on who can modify what. Is this overkill for an MVP? Probably. But I'd seen enough "we're sorry, there was a data breach" emails from other services to know I didn't want to send one.

Here's the thing: I'm still on the free tier for both Vercel and Supabase. 150+ active stables, daily usage, weather integrations, scheduled tasks - all running on free plans. This wasn't just about saving money. It forced me to actually learn optimization.

Eliminating async waterfalls so pages load in parallel instead of sequentially. Keeping bundle sizes small enough that the app loads fast on rural mobile connections - because stables aren't usually in city centers. Server-side rendering for initial loads, smart client-side fetching for interactions. Watching rendering performance in React DevTools until I understood why components re-rendered. Writing TypeScript that's actually efficient, not just type-safe. The free tier limits became a curriculum. Every time I hit a constraint, I learned something.

All of that learning paid off in November 2025, when I rewrote most of Horsemate to be properly modular. Not because I had to - it was working fine - but because I could see where things were heading.

My partner had just gotten her B-trainer license for harness racing. It's the amateur license that lets you train horses for competition in Sweden. Suddenly we needed features that regular stable owners don't: structured training logs with interval tracking, competition history and results, race-specific economy tracking for a trotting stable. Different world, different requirements.

In December, I shipped the first add-on module: harness racing functionality that users can enable if they need it. GPS-based timing for interval training, Polar integration for heart rate and recovery data, race history with results tracking - all toggleable with simple feature flags. The modular rewrite meant I could add an entire domain of functionality without touching the core codebase. Stable management and training logs in the same app, instead of scattered across five different tools.

This is what happens when you're forced to build efficiently from the start. You end up with architecture that can actually grow. The free tier constraints that felt limiting in April became the foundation for expansion in December.

The moment it stopped being just for me

By June, I'd been using Horsemate daily for two months. The backlog of "I should add this feature" had grown long enough that I started wondering if other people might want those features too.

Since getting horses, I've gotten to know a lot of horse people. I'm active in Svenska Ardennerföreningen Sydost - a regional branch of the national Ardennes horse association - and through that network I mentioned what I was building. The response was immediate and slightly overwhelming: "Where do I sign up?"

Opening it to the public meant actually building the features I'd been putting off. Multi-user stable management, where multiple people can collaborate on the same horses. Proper permission systems. Invitation flows. The kind of social features that turn a personal tool into a shared platform.

The architecture had to change. What started as "one user, their horses" became "stables as the primary entity, with users having various roles within them." This is the kind of refactor that's painful to do later but relatively easy to do early. I'm glad I did it before the user count made it scary.

// The stable-centric model that emerged
interface Stable {
  id: string;
  name: string;
  owner_id: string;
  // Location for weather integration
  latitude: number | null;
  longitude: number | null;
}

interface StableMember {
  stable_id: string;
  user_id: string;
  role: 'owner' | 'helper' | 'horse_owner';
  joined_at: string;
}

interface Horse {
  id: string;
  stable_id: string;
  name: string;
  breed: HorseBreed;
  birth_year: number;
  // Feed plans, health records linked separately
}

// And then the features that grew organically:
// - HealthEntry (vet visits, vaccinations, deworming, farrier, dental)
// - Tasks with recurring schedules
// - Feed templates and inventory tracking
// - Weather warnings from SMHI
// - Activity logs for audit trails

By December 2025, Horsemate had over 150 active stables using it daily. Not 150 users - 150 stables, each with multiple members. Real people tracking real horses, sending me feature requests and bug reports, actually depending on something I built during lunch breaks and late nights.

The features nobody else builds

One thing I'm quietly proud of is the weather integration. It's not technically impressive - just SMHI's public API hooked up to each stable's location. But I haven't seen it in any other horse management software.

Why? Because if you're building horse software from a product requirements document, weather doesn't make the list. It's not a core feature. It's not what people say they want when you ask them.

But if you actually have horses, you check the weather constantly. Before turnout. Before training. Before deciding whether the horses need extra hay. And when extreme weather is coming - cold snaps, storms, heat waves - you need to know in advance so you can prepare.

Horsemate fetches forecasts from SMHI and alerts you when weather warnings are issued for your stable's location. Red warning for extreme cold? You get an email with recommendations: check that horses have shelter, verify water supply isn't frozen, review your feeding schedule. It's not revolutionary technology. It's just useful in a way you only understand if you've been caught off guard by weather before.

That's the advantage of building for yourself. You know which "minor" features actually matter because you live with the consequences of not having them.

What I learned from accidental product development

I didn't set out to build a SaaS. I set out to stop losing track of vaccination dates. The product happened because I was solving my own problem and it turned out other people had the same one.

This is not a revolutionary insight. "Scratch your own itch" is startup advice so common it's practically a cliché. But there's a difference between knowing it intellectually and experiencing it firsthand.

When you're your own user, you can't lie to yourself about whether a feature is useful. You can't convince yourself that the UX is "fine" when you're the one getting frustrated by it every day. You can't deprioritize bugs that affect you personally.

I still use Horsemate daily for my own stable. Every feature I've added started as something I wanted. Some of those features turned out to be things only I wanted - those got quietly removed. Others turned out to be things everyone wanted - those became core functionality.

The feedback loop is immediate and honest in a way that user interviews and analytics dashboards can never quite replicate. When your own workflow improves, you know you've built something real.

The zoo continues

Chicco is currently somewhere in the living room. I saw him earlier heading toward my bookshelf - specifically toward my complete Horus Heresy collection. I'm an avid Warhammer 40,000 reader, and watching an 80-year-old tortoise slowly march toward sixty-four books about galactic civil war feels appropriately grimdark. At his pace, he'll reach them in about ten thousand years. The Emperor protects, but apparently not my paperbacks. Sam is asleep on my bed, directly on top of the very same pillow he slept on when we first took him home. Roberto is outside, running circles around one of our apple trees. There might be a very confused squirrel somewhere.

The horses need their lunch check-in soon. Horsemate will remind me, because I built it to remind me, because I kept forgetting before I had something to remind me.

I'm not sure what the lesson is here. Maybe that the unglamorous problems - tracking vaccinations, managing schedules, keeping records organized - are problems worth solving. Maybe that you don't need a brilliant idea to build something useful; you just need a problem you actually have.

Or maybe the lesson is just that if you fill your house with enough animals, eventually you'll have to build software to manage them all.

Either way, the zoo-keeper thing is working out.

If you're managing horses, are fluent in Swedish and tired of spreadsheets, you can check out Horsemate. It's the tool I built for myself that accidentally became a real product. Chicco remains unimpressed, but he's unimpressed by most things.