Skip to content
JournalTORIS / FIELD NOTES

← Blog Project notes

[Case Study] bubbleBible: Designing a Mobile-First PWA That Builds a Daily Scripture Habit

A case study of bubbleBible, a Bible platform built on habit and community: its PWA strategy, restrained gamification, and real-time community architecture.

10 min read Read the Korean original

Joohwan Yu · Founder, Full Stack Developer

Toris · Published

Contents

Q. How did a solo developer make a daily-notification habit app work without going native? Home-screen entry, daily notifications, and offline support all come from one web codebase using a PWA and Service Worker push notifications, so it ships instantly with no store review.

This is a frontend technical case study of bubbleBible, a mobile-first Bible platform that Toris (토리스) is designing and building. It covers the decisions that make a “one verse a day” habit-formation product work on web technology: the PWA and push notifications, restraint in gamification, the real-time architecture for church and small-group communities, and accessibility.

Product Snapshot

ItemDetails
Product namebubbleBible-FE
Development start2025.08
Tech stackReact, TypeScript, Next.js, Tailwind CSS, PWA, Push Notifications
StatusIn development
Core valueA daily one-verse reading habit plus sharing centered on churches and small groups

Key Decisions at a Glance

DecisionChoiceTrade-off
Distribution channelPWA (single web codebase)Gives up some notification and offline experience compared with native, gains instant deployment with no store review
Habit triggerService Worker based push notificationsNeeds server-side sending infrastructure, hence the FE/BE split
Reward designRestrained gamification (low reward balance)Gives up some engagement metrics, protects the core of meditation
Community real-time behaviorWebSocket real-time updatesMore implementation complexity than polling, makes the community experience work
Content storageBible text from a public API, only user data in our own DBDepends on an external API, but removes content operation costs

Advertisement

1. Whose Problem, and What Problem: The Product Hypothesis

The problem with Bible reading is not access to content. There are already plenty of Bible apps and websites. The real problem is persistence. Even users who want to read get tripped up by small frictions like “what is today’s reading?” and “where did I stop yesterday?”, and the habit breaks. And given the nature of faith practice, a habit kept up together inside a community (church or small group) is far stronger than one that relies on individual willpower alone.

bubbleBible’s product hypothesis combines these two observations.

① Lower the barrier to entry with the smallest unit, one verse a day; ② provide a trigger with a notification at a set time each day; ③ have people share what they read with their church or small-group community. Together, this can raise the persistence of the reading habit more than existing approaches that rely on individual willpower alone.

This design applies the classic structure of a habit-forming product (trigger, action, reward, social reinforcement) to the domain of a faith routine. The hypothesis also started from the developer’s own need, wanting to read the Bible every day but failing to keep it up, so I began with the first validation user already in house.

2. Constraints

  • People: One person for frontend design, development, and operations.
  • Distribution channel: There are no resources to build, get reviewed, and maintain native apps for iOS and Android separately. This constraint all but forced the core architectural decision of a PWA. See section 3.2 for details.
  • Content: There is no reason to build the Bible text data myself. I use a public API, and the product’s value comes from the experience layered on top of the text (habit and sharing).
  • User spectrum: A church community spans a wide range of ages. A UI designed for young users quickly becomes an accessibility problem, so accessibility was a core requirement, not an add-on.

3. Technical Design and Trade-offs

3.1 Mobile First: A Default Set by Usage Context

“One verse a day” is consumed not at a desk but on the commute, before sleep, or on the move. Since it was obvious from the usage context that desktop is a secondary channel and mobile is the primary screen, I chose to treat the mobile layout as the base and scale up to larger screens, rather than shrinking a desktop layout.

/* Mobile-first media query */
.container {
  padding: 1rem;
}

@media (min-width: 768px) {
  .container {
    padding: 2rem;
  }
}

Securing touch target sizes and loading speed on mobile networks were required items that came with this decision.

3.2 PWA: The Distribution Strategy I Chose Instead of a Native App

Getting daily notifications and entering with one tap from the home screen is typically the territory of native apps. I compared the options.

AlternativeProsWhy I dropped it
Native apps (iOS + Android)Best notification and offline experienceDeveloping for two platforms, store review, and keeping up updates are costs a one-person setup cannot bear
Cross-platform (React Native, etc.)Single codebaseStill the upkeep cost of a store release pipeline, plus a codebase separate from the web
PWASingle web codebase, instant deployment, home-screen install, push notificationsNone (adopted)

A PWA is a compromise, but a calculated one. A Service Worker meets the minimum requirements for a habit-forming product (a home-screen icon, push notifications, basic offline support), and deployment is a single web deploy. Being able to ship improvements even daily with no store review is a decisive advantage for an early product that needs to run its feedback loop fast.

// Register the Service Worker
if ('serviceWorker' in navigator) {
  navigator.serviceWorker
    .register('/sw.js')
    .then((registration) => {
      console.log('Service Worker registered');
    })
    .catch((error) => {
      console.error('Service Worker registration failed:', error);
    });
}

3.3 Push Notifications: Making the Habit Trigger Work Technically

In this product, push notifications are not a marketing channel but the product’s core mechanism. Without a “trigger at a set time each day,” the habit-formation hypothesis itself falls apart.

// Request notification permission
const requestNotificationPermission = async () => {
  if ('Notification' in window) {
    const permission = await Notification.requestPermission();
    if (permission === 'granted') {
      // Send the notification
    }
  }
};

I settled on two principles while implementing this.

  1. Put the permission request in context. Once browser notification permission is denied, it is hard to reverse. Instead of asking immediately on entry, you have to ask in a context where the user understands the value of notifications, if you want to protect the approval rate.
  2. Keep notifications restrained. I don’t send any notification outside the single purpose of the daily verse reminder. For a notification used as a habit trigger, trust is the asset, and the moment noise gets mixed in, users turn notifications off altogether.

Technically, background push needs server-side sending infrastructure, which is the point where the frontend alone could not be self-contained. That is also part of the background for the FE/BE split (bubbleBible-FE).

3.4 Gamification: Balancing Rewards and Restraint

I implemented the “reward” stage of the habit loop as a points, levels, and achievements system.

  • Reading the Bible / writing a comment / liking gives points
  • Accumulated points raise your level
  • Meeting specific conditions earns an achievement

In this domain, gamification is a double-edged sword. It is a proven way to raise engagement, but if overdone it backfires, turning the essence of meditation into point collecting. My design criterion was “rewards only work up to getting the action started, and do not replace the meaning of the action,” and I chose to keep the reward values boldly low. The conclusion of this implementation is that the success of gamification lies not in the sophistication of the system but in the balance of restraint.

3.5 Community: Architecture for Real-Time and Permissions

The church group community, which carries the social reinforcement axis, consists of meditation sharing, prayer request sharing, and group activity stats. There were three technical problems to solve.

  1. Real-time updates. Shares and reactions have to show up in real time for the community experience to work. I implemented WebSocket-based real-time updates instead of polling.
  2. Permission management. Church groups have a real hierarchy of pastors, leaders, and members. I modeled this with role-based access control (RBAC), so that per-group permissions are managed in role definitions rather than in conditionals scattered across the code.
  3. Moderation. A faith community is still a community. I included a report feature for inappropriate content from the start, to secure a minimal mechanism for operators to step in. My judgment was that the moment you open community features, moderation is not optional.

I chose a split structure where the Bible text comes from a public API and only user data like highlights and bookmarks is stored in our own database. Separating the storage strategy for content (immutable, public) from user data (mutable, private) reduces both cost and complexity. For search, I used the nature of the Bible text (fixed, finite text) to implement client-side search, giving an instant search experience with no server round trip.

3.7 Performance: The Basics of a Mobile Product

I worked through three performance problems in order: slow initial load, data usage from images, and excessive re-rendering.

  • Code splitting: Splits non-critical paths out of the initial bundle to shorten time to the first screen
  • Image optimization + lazy loading: Improves mobile data usage and perceived speed
  • React.memo: Blocks unnecessary re-rendering on frequently updated screens like the community feed

3.8 Accessibility: A Baseline Requirement the User Spectrum Demanded

As noted in the constraints in section 2, a church community covers a wide spectrum of age, digital skill, and physical condition. I treated accessibility as an implementation rule rather than a post-launch improvement.

  • Semantic HTML as the base markup principle
  • Proper aria-labels for screen readers
  • Navigation support so every feature can be used with the keyboard alone

4. Validation with Users and the Community

The validation of this product has two layers: an individual user keeping up the habit, and adoption at the community level of a church or small group. The latter is what makes this product distinctive, because for community features the unit of adoption is the group, not the individual.

  • The developer’s own daily use (dogfooding): For a habit-forming product, if the person who built it cannot keep the habit, the hypothesis has been rejected. I used the one-verse-a-day flow myself as part of my daily routine and kept refining the points of friction: notification timing, the first screen after entry, and the number of taps until reading is done.
  • Features shaped by community needs: The makeup of the community features (meditation sharing, prayer request sharing, group activity stats) and the role structure of RBAC model how real churches and small groups run. The report feature and moderation mechanisms in particular reflect a stakeholder view: “when you move a community online, the responsibility to manage it moves with it.”
  • Tuning the gamification balance: The “restraint” standard in 3.4 is not a desk decision. It came from watching motivation to use the app change when rewards were too generous, and adjusting. The balance between raising engagement metrics and protecting the product’s purpose could only be found by watching real usage.

As a product still in development, the current validation standard is not quantitative metrics but a qualitative habit signal: “do people keep notifications on, and does the daily flow stay unbroken?” Expanding the beta to the community level is the next validation step.

5. Operations and Current Status

  • Deployment: Web deployment on Vercel. Thanks to the PWA choice, improvements go live immediately with no store review.
  • Offline: Basic offline support based on a Service Worker is already implemented.
  • Operational burden: Because content (the Bible text) is delegated to an external API, there is no content operation cost, and operations focus on community moderation and the stability of the notification pipeline.

The roadmap, in priority order, is as follows.

  1. Stronger offline support. Go beyond the current basic support so the whole reading flow works offline. This ties directly to the core context of use on the move.
  2. Multilingual support. Offer Bible text in various languages to widen the user base.
  3. AI-based recommendations. Consider personalized verse recommendations once reading-pattern data has accumulated. Data accumulation is the prerequisite.

6. Lessons to Reuse in the Next Product

  1. For a one-person team, a PWA is the default strategy for a mobile product. The iteration speed from instant deployment with no store and a single codebase more than makes up for what it lacks compared with native. It is not too late to go native after validating with a PWA.
  2. Notifications are a trust asset, not a feature. A notification used as a habit trigger must keep a single purpose, and the permission request must come in a context where value has been conveyed. A notification that has been turned off effectively never comes back.
  3. In gamification, restraint is the heart of the design. Use the reward system only to get actions started, and don’t let it replace the product’s essential value with reward collecting.
  4. A community feature is a package of three: real-time, permissions, and moderation. If you open it with any one missing, it will come back as an operational problem. Moderation in particular is needed from day one.
  5. Separate the storage strategy for content and user data. If you delegate immutable, public content to an external source and own only mutable, private data, the scope of a one-person operation shrinks to a manageable size.
  6. Accessibility is a requirement derived from defining the target user. For a product with a wide user spectrum, accessibility is not an ideal but a question of market coverage.

Advertisement