How Dognet kept building a new product with zero frontend developers, without hiring one

Their only Vue developer resigned mid-build. Instead of hiring or renting a replacement, Dognet's own non-programmers now ship the frontend through a pipeline we built - and a GrownApps senior approves every merge.

0
frontend developers on staff today
1 month
of a senior developer's salary: the price of the whole pipeline
Every merge
approved by a GrownApps senior before it lands

At a glance

Client

Dognet runs an affiliate network across Central Europe and the Balkans, 13+ years in, and is building a new product line in PR tooling. Engineering: two backend developers and a CTO who codes. Zero frontend developers. Stack: Vue, Jira, Bitbucket, Claude Code, a custom lite Jira MCP server.

Challenge

The whole frontend of the new product sat with one Vue developer. In spring 2026 he gave a month's notice, and the replacement search found no one who fit.

Solution

AI Delivery Enablement: we installed an agentic delivery pipeline that turns a Jira story into a reviewed pull request, designed the governance around it, and kept the review seat. Since spring 2026, active.

Outcome

Months later the product is still being built, by people who are not frontend developers, with a GrownApps senior approving every merge. The seat is still running and still paid.

The gap

Dognet has run an affiliate network across Central Europe and the Balkans for more than thirteen years, and is now building a new product line for PR and adjacent work. The engineering team was small and senior: two backend developers and a CTO who codes. The whole frontend of the new product, built in Vue, sat with one person. In spring 2026 that person gave a month's notice. Stevo, Dognet's CEO, did the obvious thing first. He looked for a replacement. "Hľadali sme aj nového, ale nenašli sme správny fit." (We were also looking for a new one, but we did not find the right fit.) He also called us. We'd talked about agentic development at a ski event a month or two earlier, and the first ask was the obvious one: could we recommend a frontend developer, or lend one for a few months? Stevo says he wasn't afraid: in the AI era, he knew they'd manage. David's read is less relaxed. Across two weeks of calls, Stevo was considerably more nervous than his answers now suggest. Both accounts are on this page on purpose.

What was at stake:

The entire frontend of the new product sat with one person, and his last day was a month away.
The replacement search had already run, and failed.
Two backend developers and a CTO without the hours to write Vue could keep the backend moving. The frontend would have stood still.
No customer deadline forced anything. The clock was the notice period.
In about two weeks, the question changed from "who replaces him" to "does the job still need a person in it".

The decision

Three things made the third answer possible. Dognet's frontend work arrives as specific Jira stories written by people who know the product. The codebase is a single Vue application. And the CTO can judge output, without the hours to write frontend himself. That's the shape where an agentic pipeline stops being a demo and starts being a delivery system. "Spolu s teamom sme sa zhodli, že to je dobrý nápad. Proste nerobiť to po starom." (Together with the team we agreed it was a good idea. Simply not to do it the old way.) - Stevo, Dognet's CEO Two conditions came with it. It had to work the first time, because Dognet's own people would operate it. And the price had to beat the alternative: we built the whole pipeline for one month of a senior developer's salary.

What had to be true:

Work arrives as specific tickets written by people who know the product
The codebase is one application
Somebody technical can judge the output without the hours to write it

What we built: one trigger and one hard wall

Everything interesting sits between the trigger and the wall. One trade-off was made on purpose: the agent could've had narrower write permissions and been less productive. Dognet and GrownApps chose the more capable, slightly more exposed setup, with the merge wall as the backstop. We say so out loud.

1. The trigger

A Jira story is moved into a dedicated state, in practice by Michal, the CTO. The story gets its own branch and its own running instance.

2. Context assembly

A custom lightweight Jira integration reads the title, the description, any media and the story's chat thread, screened for anything shaped like a prompt injection, and hands the model roughly 300 to 500 tokens of context per story. A standard Jira MCP server hands it 5,000 to 15,000.

3. Execution

The context is checked against a knowledge base that describes how this product is built, the agent works, and it posts to the team's channel when it's done, or stuck on a question.

4. The wall

A Bitbucket repository rule refuses any merge without an accepted pull request. No prompt can talk the agent past it.

The review seat

This is the difference between using AI and being responsible for it. The seat is two people with deliberately different jobs, and nothing merges until the first of them has approved it. The first reviewer reads the code for logic and tidiness, and for security holes - in Miro's words, "to check if AI did not take any shortcuts." Miro built the pipeline and sits in that seat. The second reviewer never looks at that story's code: on a periodic cycle they audit the knowledge base the agent works from - does the AI still understand what it's supposed to do with this product's stories? The failure modes are different, so the roles are kept apart. "So we're responsible for both building the pipeline and approving its outputs." - David Melich, GrownApps CEO. That seat is still running today, and Dognet still pays for it.

Reviewer 1 reads the code
Nothing merges without approval
Reviewer 2 audits the knowledge base
Periodic reflection pass
Still running, still paid

What's true today

The product hasn't launched. This page claims something narrower and, we think, more useful. What this page doesn't claim: a launch date, because none exists yet; a velocity percentage, because none was measured; euro figures. "Front-end už vedia robiť aj neprogramátori a to je základ." (Frontend can now be done even by non-programmers, and that is the foundation.) - Stevo, Dognet's CEO The pipeline isn't perfect. The small tweaks are what you'd expect from a capable but fast junior: an improper i18n structure here, something hardcoded to save time there. Review catches them. The harder failure was a leak in the wrong direction: the agent started sneaking implementation detail into a story's feature description. The fix was to tighten the reflection definition and let the same agent rerun it over the knowledge base. The loop that caught it is the loop we're paid to sit in. No one at Dognet was told to "use AI". A specific job disappeared, a specific pipeline replaced it, the repository forbids it from merging its own work, a senior approves every merge, and a second person checks whether the AI still understands the product. That's what we mean by AI, the mature way. Rescue. Rebuild. Reinvent.

What the numbers say:

0 frontend developers on staff - and the frontend has kept shipping for months, moved through the pipeline by Michal and the product people who write the stories
1 senior month - the price of the whole pipeline
300 to 500 tokens of context per story instead of 5,000 to 15,000
Every merge carries a GrownApps senior's name
Still paid, still running

Before and after, without a launch date

	Before GrownApps	After GrownApps
Frontend developers on staff	One, giving notice	Zero, frontend still shipping
Who ships the frontend	One Vue developer	Non-programmers, through the pipeline
Jira context per story	5,000-15,000 tokens (standard MCP server)	300-500 tokens (custom lite integration)
Merge control	One developer's judgment	Repository rule + a senior's approval
Review	Nobody dedicated	A two-person seat, still paid

Questions we get about this

When the only person who can do a job leaves, a company has three answers: hire, rent, or change the job. The third one is available when the work arrives as specific tickets, the codebase is one application, and somebody technical can judge output without the hours to write it. The review seat is what makes it defensible to the people who have to live with the code.

What does this cost?

The install is €9,500, fixed. The review seat is a flat €2,000 a month. It's optional, and you can cancel it any time. For scale: a senior developer month runs around €10,000, and Dognet's whole pipeline cost about one of those.

Would this work for us?

It works where the work arrives as specific tickets, the codebase is one application, and somebody technical can judge the output. The stack matters less than that shape; Dognet's happened to be Vue with Jira and Bitbucket. If your stories are vague or your codebase is five services with no owner, the first conversation ends with "hire" or "rent", and we'll say so.

We already have senior engineers. Do we need the seat?

Probably not. The seat exists for teams with no one to check the AI's output and its understanding of the product. If your seniors can do that, keep the money.

What can the pipeline not do?

Merge. That's a Bitbucket repository rule, not a prompt.

Who is liable for code an AI wrote?

A named GrownApps senior approves every merge before it lands. That's the point of the seat, and the question we'd ask any supplier who ships AI-written code.

What if we stop the seat?

The pipeline is yours and keeps running. Someone of yours then takes the two jobs: approving every merge, and checking what the agent still understands.

Isn't this just AI-washing?

The section on where it still goes wrong is our answer. A pipeline forbidden from merging its own work, with two humans in the loop, is the opposite of a label.

A key developer just gave notice, and the roadmap didn't?

The first conversation is thirty minutes and free. It usually ends with one of the three answers above, and we'll tell you which one we'd pick for you, and why. With David Melich, CEO. Prefer email? david@grownapps.io. Not there yet? The Hard Ship is our biweekly letter on renewal war stories, including the long version of this one: https://www.linkedin.com/newsletters/the-hard-ship-7465044420984471552/