From Novai to TAMSIV: renaming an app solo

Key takeaways: Renaming an entire application (monorepo, Android package, deep links, backend, configs) is a massive undertaking — 847 lines changed across 73 files. The key: proceed in layers (Android package first, then configs, then source code, then comments), test each layer before moving to the next, and absolutely do not postpone this decision. The longer you wait, the more painful it becomes.

There are decisions you put off for weeks. Renaming an entire application is one of them. But at the end of November 2025, I realized that Novai had to die for TAMSIV to be born. The name wasn't working, the product deserved better, and every day of delay made the task bigger.

Here's the full story of this solo rebranding — from initial brainstorming to the final commit.

Why wasn't the name Novai working?

Novai was supposed to evoke "new AI". In theory, it worked. In practice, no one made the connection. The feedback was unanimous:

• Generic: "Novai" sounds like dozens of other tech products. Try Googling "Novai" — you'll find consulting firms, AI startups, SaaS software. Impossible to stand out.
• Not memorable: the name says nothing about the product. A voice productivity app? A chatbot? A data tool? Novai could be anything.
• No story: a good name tells a story. Novai tells nothing.

I needed a name that carried the concept. Not just a pleasant sound — a name that was a pitch in itself.

How was the name TAMSIV born?

TAMSIV is an acronym: Tasks Assisted by Synchronized Memos, Voice Intelligence. Each letter describes a feature:

• TA — Tasks: the core of the app, task management
• M — Memos: voice notes structured by AI
• S — Synchronized: the collaborative and multi-device dimension
• IV — Voice Intelligence: voice as the primary interface

The name IS the pitch. In 6 letters, you know what the application does. This is what's called a descriptive name — as opposed to evocative names (like Apple) or arbitrary names (like Kodak).

Additional advantage: "TAMSIV" is unique. Zero Google results before launch. SEO starts from scratch, but at least there's no competition for the term. For a solo dev, this is crucial — no ad budget to outrank a namesake.

How to plan a rename in a monorepo?

The TAMSIV monorepo has three components: frontend/ (React Native), backend/ (Node.js/Express), and website/ (Next.js). More than 400 files contained "novai" in various forms: novai, Novai, NOVAI, novai://, com.novai.

I proceeded in layers, from most critical to least critical:

1. Layer 1 — Android Package: com.novai → com.tamsiv. This is the foundation. If it breaks, nothing compiles.
2. Layer 2 — Config files: build.gradle, package.json, .env, Firebase configs, Supabase URL.
3. Layer 3 — Source code: imports, references, service names, endpoints.
4. Layer 4 — Comments and docs: README, CHANGELOG, comments in the code.

Each layer was tested individually before moving to the next. This avoids the nightmare scenario: 400 files modified at once, a build that fails, and no idea which change caused the problem.

What are the technical pitfalls of an Android rename?

The Android build.gradle uses the package name in six different places:

• applicationId — the unique identifier on the Play Store
• namespace — the Java/Kotlin namespace for code generation
• manifestPlaceholders — variables injected into AndroidManifest.xml
• signingConfigs — signing configuration (keystore)
• resValue — resources injected at compile time
• buildConfigField — build constants

Forget just one, and the build fails with a cryptic error message. I checked each occurrence manually.

Deep links are another pitfall. TAMSIV uses the scheme tamsiv:// for referral links (tamsiv://invite/{code}). Before the rename, it was novai://. The migration must be clean — no transition period where both schemes coexist, as that creates confusion.

How to manage the backend and infrastructure renaming?

The backend is not spared:

• Logs: every log contained "Novai" as a prefix. Migration to "TAMSIV".
• Error messages: user-facing messages ("Welcome to Novai") must match the new name.
• Environment variables: NOVAI_DB_URL → TAMSIV_DB_URL (even if technically it changes nothing, readability matters).
• Railway: the service was called "novai-backend". Renamed in the Railway dashboard.
• Supabase: the project remained the same (Supabase URLs don't change), but comments in migrations referenced "Novai".

On the website side, the task was similar: meta tags, Open Graph, footer, legal notices, terms of service, privacy policy — everything that mentioned "Novai" had to change to "TAMSIV".

How to verify that no references were missed?

After the rename, I ran a grep -ri "novai" . across the entire repo. Result: zero occurrences. This is the only way to be sure.

But grep isn't enough. You also need to:

• Full Android build: gradlew assembleDebug then gradlew assembleRelease
• Backend tests: npm test to verify that endpoints are working
• Website build: npm run build to verify that Next.js compiles without errors
• Deep link testing: verify that tamsiv://invite/test correctly opens the app
• Firebase: verify that google-services.json matches the new package

I did everything in order. The Android build failed on the first try — a forgotten import com.novai.BuildConfig in a generated Java file. Corrected, rebuilt, OK.

What impact does a rename have on the Play Store?

Changing the applicationId means creating a new application on the Play Store. This is the most important point to understand: Google identifies apps by their applicationId, not by their name. com.novai and com.tamsiv are two different apps in the eyes of the store.

Consequences:

• Ratings and reviews start from scratch
• Installations are not transferred
• Existing users must reinstall (or you manage a server-side migration)

For TAMSIV, this was acceptable — the app was in alpha with a few testers. If you have thousands of users, think very seriously before changing your applicationId. You can change the displayed name without touching the package.

What lessons can be learned from this rebranding?

Here are the lessons I learned, after 847 lines changed across 73 files:

1. Do it early: the longer you wait, the more painful it becomes. If your name bothers you after 3 months, it will still bother you in a year — with 10x more files to modify.
2. A good name is an investment: a name that tells your product's story is free marketing. TAMSIV sells itself through explanation.
3. Proceed in layers: from most critical to least critical. Test each layer. Don't make a mega-commit of 400 files.
4. Grep is your friend: a final grep -ri is mandatory. The human eye misses things, regex does not.
5. Zero new features: accept that this day produces nothing visible to the user. It's technical debt paid in advance.

How to choose a good name for your app?

If you're in the name selection phase, here are my criteria:

• Googleable: the name must be unique. Type it into Google before committing.
• Pronounceable: if people can't say it out loud, they won't recommend it.
• Descriptive or memorable: either the name describes the product (TAMSIV), or it's so unique that it sticks in your mind (Spotify).
• Available: domain, Android package, social media username. Check everything before choosing.
• Short: ideally 6 letters maximum. Beyond that, it becomes difficult to remember and type.

Tools like Namelix or NameMesh can help with brainstorming, but the final decision is always human. My advice: ask 5 people to repeat the name after hearing it just once. If 4 out of 5 remember it, that's a good sign.

Did the renaming change anything for the product?

Yes, and not just technically. Having a name that carries meaning changed how I talk about the product. When I build in public, when I say "TAMSIV — Tasks Assisted by Synchronized Memos, Voice Intelligence," people immediately understand. With "Novai," I always had to explain.

The journey of 650+ commits for TAMSIV is inseparable from this decision. Renaming is not a technical detail — it's a foundational moment. The app found its identity that day.

One day for zero new features. But TAMSIV finally had its name.

FAQ

How long does a complete application rename take?

For TAMSIV (monorepo with React Native frontend, Node.js backend, and Next.js website), it took a full day. The volume: 847 lines modified across 73 files. The time primarily depends on the number of components and the size of the codebase.

Can a published app on the Play Store be renamed?

You can change the displayed name (title) without issue. But changing the applicationId (com.example.app) creates a new application in Google's eyes. Reviews, installations, and rankings are not transferred. For an app in production with thousands of users, this is rarely recommended.

Does a good app name require an acronym?

No, it's one choice among others. An acronym works when each letter has a clear meaning and the resulting word is pronounceable. "TAMSIV" passes this test. But names like "Notion" or "Linear" also work very well without being acronyms.

How to avoid breaking existing links after a rename?

If you have deep links, shared links, or QR codes in circulation with the old scheme, you must maintain a temporary redirect. For web URLs, a 301 redirect works. For mobile deep links, you can declare both schemes in the manifest for a transition period.

Does rebranding impact SEO?

For the website, yes. If you change domains, you need proper 301 redirects and to notify Google via Search Console. If you keep the same domain (like TAMSIV), the impact is minimal — just update meta tags and content. The new name will be indexed in a few days.