Case study · Mobile app
Happy Tummy
More time for the product.
Less backend to assemble.
Food guidance, recipes and first tastes for families. Norbix connects the content, accounts, photos and messages behind it—so the small team can focus on the parent experience.
- Norbix supplies
-
Data · Accounts · Files
Messaging · Environments - Built with
-
Claude Code
Norbix CLI + TypeScript SDK - Deployment
-
Self-hosted Norbix
Customer-owned AWS services - Project stage
- Tested in TEST
Production switch ahead
Record a first taste
Guidance for the next stage
Find a recipe that fits
The result so far
An existing app.
A connected backend.
A migration
rehearsed.
- 28,941
- logins imported with existing password hashes
- 3
- languages served from the same content records
- 11,050
- child photos copied in the migration rehearsal
- 15
- collections configured on the same backend
Migration rehearsal on Norbix TEST. Existing passwords were verified with a proof account.
The brief
Keep what families love.
Replace the work behind it.
Kristina and Domantas built the app they wished they had for their first child. Moving its backend meant protecting years of family history while making the next version easier to build.
- 01
Keep parents’ history
Bring accounts, children and favourites across without breaking the links between them.
- 02
Publish in three languages
Manage foods and recipes together, with the right language returned to each app.
- 03
Protect each family
Keep a parent’s photos, tastings and child profiles private to that account.
- 04
Rehearse before the switch
Test the actual app, repeat the setup and review changes before touching production.
The Norbix approach
One project behind
the whole experience.
The team configured connected backend capabilities instead of assembling a separate service and set of tools for each need. Its own app, provider accounts and product rules stay under its control.
Inside this project One content model. Three language editions.
Manage all three language editions from one set of records.
Foods, recipes, source references and age guidance live as connected records in Norbix. Shared allergen terms keep the catalogue consistent. The app requests Lithuanian, English or Polish and receives the right text; search and sorting work in that language too.
- 181 foods and 110 recipes in the rehearsal copy
- Translated records, relationships and shared taxonomies
- An existing workspace for managing structured content
The team reused content management and multilingual delivery, keeping its custom work focused on how parents discover and use the guidance.
A food record becomes useful guidance
Keep the history. Keep each family’s data their own.
A backend move should not mean starting again for every parent.
The rehearsal imported 28,941 logins while preserving account IDs and existing password hashes. A proof account signed in with its old password. Norbix’s own-record rules connect each parent to their children, tastings and favourites; calls with two test users checked that one could not read or change the other’s records.
- Existing account IDs and password compatibility preserved
- Own-record permissions across seven user-data collections
- Shared food content stays read-only for app users
The team reused identity and access controls around its family model, with a tested route to account continuity at cutover.
One account, several children
A tasting belongs to the family
Their photos. Their storage. One permission model.
Keep control of the bucket without building a private-file service.
Happy Tummy connects S3 in its own AWS account. Norbix supplies signed uploads, stable file IDs and owner-based access. New child photos are resized on the phone before upload; the migration script prepared display copies for existing photos. Another parent’s attempts to read or download a private photo were refused.
- Direct uploads to customer-owned S3
- Private file access tied to the signed-in parent
- 11,050 child photos copied in the recorded rehearsal run
The customer keeps its files and provider account, while the app reuses the same identity and permission system for records and photos.
Private files, connected to the app
- Parent’s app Prepares a 512 px photo
- Norbix Files Authorises access · assigns a file ID
- The customer’s S3 Stores the photo in their AWS account
Build the message journey around an existing engine.
A sender API is only one part of keeping in touch.
Norbix provides translated templates, campaign recipients, device registration and a private inbox with read state per parent. Push campaigns and inbox behaviour were tested with the sandbox provider. The project’s own SES integration is configured for email, with sandbox delivery kept as the default during rehearsal.
- Templates and campaigns instead of separate message tooling
- Device registration and each parent’s own inbox
- Sandbox testing without contacting imported real users
The team can spend its next effort on when a message should help a parent, with the surrounding messaging tools already available.
Welcome-email and admin-alert triggers, plus scheduled monthly reminders, are next steps. The current age-based app feed reads content records.
The messaging work already supplied
Sandbox providers let the team check campaigns without messaging real parents.
Rehearse the change before families depend on it.
Test the real app. Preview the move. Keep the decision with the owner.
The Norbix version has separate TEST and PROD environments. The team can preview configuration promotion, preserve collection and taxonomy IDs and roll back a promoted configuration. The English Android release build was exercised against Norbix TEST in a 37-step end-to-end run.
- 36 checks passed, none failed; one content warning
- Repeatable setup and environment-promotion previews
- No real messages sent to imported users during rehearsal
The team gets a controlled path to the production switch, rather than making the first real test on parents’ live accounts.
Configuration rollback restores a promoted configuration. The store-app production cutover is still ahead.
Rehearse → preview → approve
37-step Android end-to-end run on Norbix TEST.
One content warning; not a failed backend check.
Give the agent a backend it can actually work with.
The owner sets the rules. Claude Code does the repeatable work.
Through the authorised Norbix CLI, Claude Code converted schemas, configured roles, integrated the official TypeScript SDK and wrote repeatable setup and import scripts. The owner chose the duplicate-account rules, provider accounts and permissions, and approved production-sensitive steps.
- Project context through norbix ai init
- Discoverable commands, structured results and dry-run previews
- Setup saved as scripts the team can review and repeat
The agent worked with connected backend capabilities instead of generating and maintaining a separate service for every requirement.
The workflow used in this project
$ norbix ai init
Discover the backend’s commands $ norbix schema --json
Preview environment promotion $ norbix env promote
- The owner decides
- Rules, permissions, providers and production approval.
- The agent prepares
- Schemas, imports, SDK integration, scripts and checks.
The difference Norbix made
Build the parenting experience.
Reuse the backend foundations.
The practical gain is less infrastructure and tooling to assemble around the app. Norbix supplies connected capabilities; the team still owns the product and its rules.
Available in Norbix
- Content editing, relationships and multilingual queries
- Accounts, roles and own-record permissions
- Signed file access on the customer’s S3
- Templates, campaigns and notification inboxes
- Environment promotion and agent-ready tooling
Built for Happy Tummy
- The parent experience and food guidance
- Migration transforms and duplicate-account decisions
- Image preparation and product-specific message rules
- Final cutover and release validation
The team reported around one week for the initial backend migration rehearsal. Engineering hours saved were not measured.
The app, account imports and photo-copy runs have been tested on Norbix. The live app remains on CodeMash until the store-app cutover. Automated welcome messages, monthly reminders and parts of the account-deletion workflow still need completion.
Your next product
Give your app a backend.
Give your agent something real to build
on.
Start with connected capabilities for data, users, files and messages. Put your own engineering into the experience your customers came for.