Type at least 3 letters to search

·13 min read

Baby Rabby, Stage Two: From a Prototype to an Online Store Built to Grow

Paper sewing pattern of a baby bodysuit pinned with red pins beside the finished cream bodysuit, a tape measure and tailor’s chalk on a soft pink background with a faint bunny silhouette

Baby Rabby is our own store of baby clothes and goods. In the first stage we gave it a new identity and a working prototype. This case is about the second stage: how the prototype became a real store on Laravel, with a cabinet for parents, an admin for daily work, purchasing and a warehouse, and why we built it in this order.

Baby Rabby sells soft clothes, textiles and sleep goods for babies from birth to two years in Ukraine. The brand was prepared years ago and never opened, so we are relaunching it as our own project: the sign from 2022, a new look, and a store built the way we build stores for clients.

The first stage is told in the Baby Rabby portfolio case: the sign, the bunny hidden in the R, the drawn goods and a prototype that answered how a tired parent shops at night with one hand. That prototype was static pages and plain JavaScript. It sold nothing, and it was never meant to.

This case is about what happens after a good prototype. Most stores stall at exactly this point: the design is approved, and then the build starts from zero and drifts away from it. We took the opposite route. The prototype became the specification, and the real store had to prove, file by file, that it matches it.

Baby Rabby home page on a large screen: the bunny from behind, the promise, the season's pick and two tiles for sleep and the hospital bag
The home page of babyrabby.shop today, now served by Laravel

WHY A PROTOTYPE

Why we started with a prototype

A prototype answers the questions that are cheap to answer early and expensive to answer late. What does a parent see first? How is a size chosen when the baby's age says one thing and the height another? What does the bag ask for before checkout, and what can wait? Changing a static page costs minutes. Changing a decision that already sits in a database, an admin and three languages costs days.

So in the first stage we spent the effort on behaviour, not on infrastructure:

  • every product page shows the ship date and the 14-day exchange before the button;
  • sold-out sizes stay visible with a "tell me when it is back" button;
  • a height helper picks the size;
  • the checkout fits on one page, with the Nova Poshta branch, a different recipient and gift wrap.

Search was designed in from the start as well: structured data for every product group, a short answer under each price, Markdown copies of products for AI assistants, a parents' blog with sources and a glossary.

When the prototype stopped raising new questions, we froze it. From that moment it was no longer a draft to be "improved during development". It was the reference.

The prototype stopped being a draft and became the reference.

THE ORDER

The order of work

We built stage two in a fixed order, and each step stands on the previous one:

  1. the storefront on Laravel, identical to the prototype;
  2. the admin, so the content lives in the database and people can change it;
  3. the parent's cabinet with real orders;
  4. purchasing, counterparties and the warehouse;
  5. search and analytics, opened step by step.

The order matters more than it looks. A cabinet built before the storefront is stable has to be rebuilt each time the storefront changes. A warehouse built before orders exist has nothing to take goods off the shelf. And a store opened to search engines before its content is real teaches Google the wrong first impression. Each step here answers to the step before it, so nothing had to be redone.

PARITY

The prototype as the specification

Every page of the new store comes from the database through Blade templates: goods, categories, filter pages, the blog, the glossary, the required legal pages. The danger of such a move is small, silent differences: a missing canonical tag, a changed link, a script that no longer finds its element.

So we wrote a check that renders every page of the new store and compares it with the prototype's file, byte by byte. Before the switch the result was 374 of 374 pages and scripts identical, with 0 differences. Along the way it caught exactly the kind of thing a person would never see: one helper trimmed the trailing slash from addresses, which turned some pages into a redirect to themselves. On a live store that is a lost page in Google; here it was a red line in a report.

The switch itself was one link on the server. The static prototype stays next to the store as the way back. We did not need it, but a move without a way back is a bet, not a release.

Baby Rabby parity checks: 374 of 374 pages identical to the prototype, 255 of 255 translated files, and one product page in Ukrainian, Russian and English
The parity checks before the switch and one product page in three languages

LANGUAGES

Three languages from one source

The store speaks Ukrainian at the root, Russian at /ru/ and English at /en/. We did not build three stores. There is one source, the Ukrainian page, and the other two are built from it through a table of translated lines: tags and numbers are placeholders, so a translator cannot break markup or change a price.

A second check compares the translated pages with the prototype's translations: 255 of 255 files identical. Translating a page takes about 7 ms on the server. The table lives in the database and is edited in the admin; the dashboard counts lines that have no translation yet, so a new sentence in Ukrainian cannot slip onto the site untranslated.

The Russian version is written for Russian-speaking Ukrainians, with Nova Poshta and hryvnias. The English one also shows prices in hryvnias: it serves people who read English, while the store itself stays a Ukrainian store.

DATA MODEL

A schema for what comes next

The most expensive mistake in a young store is a database that only fits launch day. We designed the tables for the features we already know the store will need, even where the screens come later:

  • reviews with a verified-purchase mark, a status for moderation, the shop's reply and a demo flag, so example reviews can never leak into ratings or into structured data;
  • children with measurements over time, so sizes can follow growth instead of age;
  • trade-ins tied to the order line they came from, with a grade on arrival and a final credit;
  • carrots, the shop's bonus, kept as a ledger with an expiry date, never as a single number that can be overwritten;
  • suppliers and source codes on every product, ready for supplier feeds and stock sync;
  • stock per product, colour and size.

Every demo row carries its flag. The example account, the invented reviews and the sample orders exist so the cabinet can be shown and tested, and none of them is counted in money, stock or ratings.

THE CABINET

A cabinet that knows the size

There are no passwords. A parent types an e-mail, gets a code, and orders placed with that address appear by themselves. The cabinet has its own session under /kabinet, while the store pages around it stay free of cookies.

The cabinet keeps the baby's height and weight and works out the size now and the next one from WHO growth medians. So it can say that the 68 bodysuit from an order will be tight in about seven weeks and offer the 74 in time, and it filters New in and Sale by that size. For a baby store this is the difference between a list of past orders and a reason to come back.

Orders show their Nova Poshta stage and tracking number, and a size exchange stays open for 14 days after delivery. Second Round, our trade-in, takes back outgrown Baby Rabby items bought from us for carrots: one carrot is one hryvnia, carrots last six months and can pay for up to half of an order. A review earns carrots too. The hospital bag list from our blog article can be ticked off here and shared with a friend.

Baby Rabby parent's cabinet: growth chart and size now, soon too small with dates, order stages with Nova Poshta, Second Round and carrots
The parent's cabinet on an example account with invented data

A baby store sells the next size, not the last order.

THE ADMIN

An admin built for daily work

The daily work happens in Ukraine, so the admin speaks Ukrainian and is built for that work, not for a demo. It runs on the panel engine we first built for the DeZZign admin: every section is described in one definition file, and the engine does the rest.

What makes it serious is what happens on save:

  • only the fields that changed are written, and each change is logged with the old value, so any edit can be put back;
  • a form that went out of date while someone else saved is refused instead of overwriting their edit;
  • a form cut short by the server's input limit is refused as a whole, so half a product is never saved;
  • changed pages that are open to search are sent to search engines through IndexNow right after the save.

The menu folds into an icon strip, the dashboard has tabs for analytics, search, hosting and the code itself, and roles keep purchasing and the warehouse visible to administrators only.

Baby Rabby admin: overview with counters, the menu folded into icons, an order with the stages the buyer sees, and the same order on a phone
The admin with sample data: overview, folded menu, an order on a computer and on a phone

OPERATIONS

Purchasing and the warehouse

A store that cannot answer "how much did this piece really cost us" is guessing its prices. A purchase lists what was ordered by product, colour and size, with the price per piece. Delivery and other costs are spread over the lines by value: if a purchase holds ten pieces at 100 and ten at 300 hryvnias and delivery costs 400, the cheap piece lands at 110 and the expensive one at 330. The margin stands next to the site price before the goods even arrive.

When the purchase is marked received, the pieces go on the shelf at that cost. A packed order takes them off, a cancelled one brings them back, and an exchange moves both sizes. Each document keeps the shelf equal to what it says, so saving it twice changes nothing, and moving a purchase back to "in transit" removes exactly what it added.

The stock is a ledger, not a counter. Every change is a line with the reason, the document and the person, and a mistake is corrected by a new line, never by editing an old one. The stock page shows what is on hand, reserved by orders not yet packed and free to sell, what runs low, and which sold-out sizes on the site no longer match the shelf, with one button to put them right.

Baby Rabby purchasing: a purchase with landed cost and margin per line, a supplier card, stock by colour and size with reserve
Purchasing and the warehouse with sample data

RELIABILITY

What keeps it safe

Most of this work is invisible, and that is the point:

  • automated tests run against a temporary copy of the database, never against the live tables;
  • a deploy script ships the code, runs migrations and rebuilds caches, and a copy of the database is taken before every change of its structure;
  • both the store and the prototype live in private repositories, and the admin shows which commit is running on the server;
  • the store's mail goes from its own domain with SPF and DMARC records, so order letters have a fair chance against spam filters.

None of this shows on a screenshot, and all of it decides whether a store survives its first busy week.

SEARCH

Search, opened step by step

The goods are still drawn, so the store stays closed to search engines. The blog and the glossary are open: they are written to launch quality, with sources, and can start earning trust now. Every other page carries noindex, and the sitemap lists only open pages. Opening the whole store at launch is one line in the configuration.

Google Analytics starts only after a visitor allows it in the cookie choice. Search Console and IndexNow are connected, and the admin shows what is open, the robots rules for each crawler and the hosting's own bot block, which had been turning search and AI crawlers away until we found it. How we build search into a store from the first day is in our piece on e-commerce SEO built into the store.

WHERE IT STANDS

Where the store is now

Right now Baby Rabby is preparing for an active launch, and new features are connected every day. Before it opens it needs photos of the real goods instead of drawings, the seller's details in the offer, online payment and the Nova Poshta connection with real branches. The stock is counted first, so the warehouse starts from real numbers rather than from a guess.

The documents and pages a store needs before its first sale are in our online store launch checklist. How much the first year of marketing costs is in the article on the online store marketing budget, and whether to start on a marketplace or your own store is in the next one.

FOR YOUR STORE

What this means for your store

You do not need our stack to use the method. What we would keep for any store:

  • Prototype first, and freeze it once it stops raising questions.
  • Check the build against the prototype automatically, not by eye.
  • One source for all languages, with checks that nothing is left untranslated.
  • A schema for next year, not for launch day.
  • Ledgers for money and stock, never single numbers.
  • Open search when the content is real.

Build the store for next year, not for launch day.

We build stores this way for clients too. If you are planning one, our e-commerce development page describes how we work and what it costs.

FAQ

Frequently asked questions

Why build a prototype before the real online store?

Because decisions about what the buyer sees, how a size is chosen and what checkout asks for are cheap to change on static pages and expensive once they sit in a database, an admin and several languages. A prototype settles them first.

How do you make sure the new store matches the approved design?

We render every page of the new store and compare it with the prototype file by file. For Baby Rabby all 374 pages and scripts were identical before the switch, and the translated pages passed a second check of 255 files.

Can one online store work in several languages without three copies of the content?

Yes. Baby Rabby keeps one Ukrainian source and builds Russian and English from a table of translated lines, edited in the admin. A check shows any line that is not translated yet.

What should a store admin have beyond a product editor?

A history of every change with a way to put it back, protection against two people overwriting each other, roles, and the operations side: purchases, landed cost, stock with reserve and a moves log that is never edited.

When should a new store open to search engines?

When its pages are real. Baby Rabby keeps the store closed while the goods are drawn, and opens the blog and the glossary first because they are already complete and sourced.

Sources

Planning an online store and want it built to grow, not rebuilt in a year? Let's look at your plan.

Book a Strategic Session

E-Commerce Development