Made for Me: a native mobile companion that grows with every woman

The Client & the Opportunity We Partnered to Build

A woman's needs change dramatically across life stages, yet generic commerce and content apps treat everyone the same. The client's vision for Made for Me made life stage the organizing idea: an app that grows with you, tuning its content and its care to exactly where you are — from pregnancy through menopause and beyond.

The catch: the client already runs an e-commerce business on Shoptet, a popular Czech hosted store platform. Shoptet is great at being a storefront, but it cannot deliver a personalized native app experience — there is no rich product API, the blog is only HTML, and orders come out as XML. QuantumSpring joined as the delivery partner to build that native experience around the platform, not to replace it.

The Core Challenge: a rich native product on a constrained platform

The hard part was the gap between ambition and platform. The product had to feel like a first-class native app — personalized feed, community, editorial content, identity, order history, saved items, referrals — while every piece of commerce data lived inside Shoptet and could only be reached through the seams it exposes: a scrapeable blog, an XML order export, a catalog export, and a web checkout that has to stay on the store. Designing rich features around those limitations, without a fragile integration, was the central engineering problem.

Our Approach: a modern stack built for speed

The bet was to build genuinely native on a modern, uniform TypeScript stack running on Bun — one language end to end — so a tiny team could ship a broad product surface quickly and safely. The mobile app, backend, content service, admin SPA and a mock backend all live in one Bun workspace monorepo; a single install links them, and a single command runs every workspace's typecheck and tests. CI mirrors the exact same recipes, so “green locally” means “green in CI.”

Client and server never drift because they share one source of truth: TypeBox schemas in a shared workspace, consumed by every app at once. Change a field and everything re-types — a mistake fails typecheck, not production. Deterministic end-to-end tests run against a mock backend that fakes every route the app hits, and Maestro captures screens that are pixel-diffed against committed baselines. That guardrail stack is what turns a small team into a fast one.

What We Built: a rich feature set from one codebase

For its size, the product surface is broad and real: 19 native screens backed by 10 backend route groups over 12 Postgres tables, all typed against the shared contracts.

Inside the App

Every screen is bespoke — editorial serif headings, a navy-and-paper palette with a single hot-pink accent, and hand-drawn illustrations. A tour of the surface:

Architecture & Tech Stack

A modern, all-TypeScript stack on Bun, with a deliberate anti-corruption layer isolating Shoptet so the app only ever talks to clean, owned contracts.

Working Around the Platform: Shoptet, fronted not fought

The most interesting engineering is in how the app coexists with Shoptet. Rather than a brittle direct dependency, each platform limitation is turned into a clean seam:

• Blog with no API → a dedicated content service scrapes the Shoptet blog into a standard JSON Feed with a TTL cache and last-good fallback; the backend proxies it, and the app consumes a swappable content interface that never touches the scraper directly.
• Orders as XML → a sync job ingests the Shoptet order export into owned, typed tables, so signed-in members get a clean native order history with line items and tracking.
• Catalog as an export → products, variants, VAT and sale flags are imported and served through owned contracts, powering the grid, search and product detail.
• Checkout on the web → buying opens the Shoptet store in an in-app browser, so the client keeps their proven, PCI-handled checkout while the app owns discovery and identity.

Results & Outcomes: a shipped native product

We frame results as delivered capability. The app is a compiled native product — not a webview wrapper — spanning 19 screens, with the personalization, content, community, identity and order features above, deployed as three config-as-code services behind health checks.

• Broad surface, small team: a personalized feed, shop, content, forum, OTP identity and order sync, bilingual (cs/en), from one codebase.
• Safe integration:Shoptet is isolated behind an anti-corruption layer, so the platform's quirks never leak into the app.
• Engagement built in: push notifications — replenishment reminders, product-of-the-week, and life-stage content — are composed and scheduled from the same admin console the team uses for moderation and feed curation.

"

"The fun of this build was giving the client a rich native app without asking them to leave the platform they already run. We fronted Shoptet instead of fighting it, and a modern Bun/TypeScript stack with shared contracts let a very small team ship a genuinely broad product surface, fast."

Ondřej Šťastný, Co-founder & CEO, QuantumSpring

What Made This Work

Next step

Want a native app on top of your platform?

Speak directly with Ondřej Šťastný

A short expert call to map what your existing platform can and can't expose, and the fastest path to a rich native product on top of it.

Clear guidance. Senior expertise. No sales talk.

Book a call with OndřejSend a question