There's a photo somewhere from 2023 — the moment Soilnetic got called up as Best Student Company in Latvia. We were still in high school. None of us had built a real product before — not something with a case, a board, sensors, and code that had to survive actual soil and actual weather instead of a demo table. Soilnetic was an automatic plant watering system: hardware and software together, sensors reading moisture, a schedule that adjusted itself so a plant survived even if you forgot about it for a week.
I remember the feeling more than the moment itself: the sense that a bunch of us who'd never shipped anything real before had actually pulled it off. Underneath the trophy, the idea itself was simple — take something people mean to do but keep forgetting, and let a quiet system do it for them.
What I didn't know yet was how much I'd end up leaning on that first experience, or that the idea underneath Soilnetic — let a system quietly do the thing you keep forgetting to — was one I'd end up rebuilding, alone, more than once.
What that first product actually taught me
Soilnetic was the first time I saw a product go all the way through: an idea, a prototype, hardware that had to actually work, software wrapped around it, and then a team of high schoolers standing in front of judges trying to explain why any of it mattered. I learned things there that no coursework had gotten to yet — how a good idea on paper turns into a much harder set of tradeoffs once it has to run on real hardware, how much of "finishing" a product is unglamorous debugging rather than the fun initial build, and how differently a thing reads when you're demoing it to someone outside your own head versus building it for yourself.
None of that showed up as a line on a resume. All of it shows up now, every time I start something new.
Building without the team
When I started building on my own — Blogizi, Flwkit, Postezi, the rest of what lives under ByteMind now — the biggest shock wasn't the workload. I'd expected that; I'd been coding since I was ten, so shipping fast was never the bottleneck.
The shock was doing every part of it myself. With Soilnetic, the hardware side, the software side, and the "explain this to a judge" side were split across people who each carried a piece. Solo, all of that collapses into one person. There's no one else to hand the soldering to while you fix the firmware, no one to sanity-check whether an idea is actually good before you've sunk a week into it.
That changes how you build. With Soilnetic, mistakes got caught by someone noticing out loud. Alone, the only thing that catches a bad idea is shipping it and watching what happens. If something doesn't land, I don't have a teammate to tell me — I need a week, a pivot, and the next attempt.
The same idea, twice more, alone
It took me a while to notice that I kept building the same shape of thing.
Soilnetic watered the plant so you didn't have to remember to. Blogizi does something similar for writing — it reads your codebase and your git history and drafts the blog post you meant to write about what you shipped this week, so the habit doesn't die the way a lot of engineering blogs quietly do. Postezi does it again one layer downstream: once something exists — a post, an update, an announcement — it gets it out across Bluesky, LinkedIn, Threads, and X without you having to sit down and do the forgettable, repetitive part by hand.
None of that was a deliberate callback when I started either project. I didn't sit down and think "let's rebuild the watering system for content." But the instinct underneath all three is identical: find the thing a person means to keep up with but won't, and put a system between them and the forgetting. Soilnetic just happened to do it for a plant, built by a handful of high schoolers who didn't yet know that's what we'd stumbled onto. It took two solo products, years later, to actually recognize the pattern.
The actual difference
If I'm honest, the biggest shift isn't skill — it's how visible your own mistakes are. With Soilnetic, being new at this together meant we caught a lot of things as a group, just by talking. Building solo, I only find out what's wrong by shipping and watching — a slower, lonelier feedback loop, but one that's entirely mine to run.
I don't think either mode is strictly better. Soilnetic was where I learned that a real product is mostly made of unglamorous problem-solving, not the exciting parts. Blogizi and Postezi are where I've had to apply that lesson without anyone else in the room to remind me of it. What I have now that I didn't back then is the long view — enough distance to look at a watering system for plants and a publishing pipeline for blog posts and recognize them as the same instinct, wearing different clothes.