Rabsnet

When I took over engineering on RabsNet, the app was essentially just a basic reader where people would come in, read a daily devotional, and leave. But beneath the surface, it had serious usability and performance issues, lots of confusing screens and was even at risk of getting taken down from the app stores. My main goal was to turn it into a fast, reliable, and engaging daily companion that feels great in the user's hands, so here is an understanding of what was broken, how I fixed it, and the results.

§1. Turning Reading into an Interactive Experience

Originally, the app only offered a passive reading experience where users would scroll through text and immediately close the app, with no way to ask questions, reflect on what they read, or get any form of feedback.

To make the app feel alive and personal, I wanted to turn reading into an active conversation:

• ›I built a step-by-step study guide that actively walks users through reading, understanding, and applying the message to their daily routines.
• ›I integrated an AI assistant that reads what the user writes and gives them encouraging, thoughtful feedback on their reflections, making the app feel like a supportive study companion.
• ›I made sure the screen gracefully locks the input fields while the AI generates answers so users don't accidentally double-tap or think the app froze while waiting.

Because of this, users stopped just skimming through text and started actively writing, reflecting, and returning every single day, which drove our 30-day user retention up by over 40%.

§2. Making the App Fast and Smooth

People have very little patience for mobile apps that stutter when scrolling or take forever to open and originally whenever someone opened the study plans or history screen, the app tried to download every single article and full-resolution photo all at once. On budget Android devices, this caused painful 20-second loading screens, chewed through precious mobile data, and caused severe lag that made the phone freeze up.

To eliminate these bottlenecks and make scrolling feel completely effortless:

• ›I set up the app to save articles locally on the device after downloading them once, meaning that when a user returns to the screen, everything loads instantly from cache while quietly checking for new updates in the background this process is called stale-while-revalidate or Lazy Hydration .
• ›Instead of forcing the device to draw hundreds of hidden items off-screen, the app now only renders the items currently visible in front of the user.
• ›I set up the feeds to fetch items in small, bite-sized batches only as the user scrolls down, rather than dumping the whole catalog into memory on launch.
• ›I made sure photos are automatically downsampled to fit the phone screen before displaying, keeping memory usage strictly under control.

This slashed screen load times from 20 seconds down to under 2 seconds (and instant on cache hits), while list scrolling reached a buttery-smooth 60 frames per second even on entry-level phones.

§3. Handling Bad Internet and Preventing Duplicate Posts

Fun fact: this is a critical detail that gets easily overlooked, but mobile internet can be very unstable in our target regions, where users frequently run into patchy cellular connections, dropped signals, and latency spikes. In the past, if someone tapped "Enroll" or posted a reflection while their connection lagged, they would tap the button four or five times out of frustration, and this ended up creating duplicate posts, multiple enrollments, and messy database race conditions.

To fix this, I designed a resilient request flow that protects both the user and our backend:

• ›Every time a user takes an important action, the app attaches a unique ID to that request before sending it out.
• ›If the request gets sent multiple times because of impatience or automatic network retries, the server spots the ID and simply returns the first successful result instead of processing it twice.
• ›If the connection drops completely, the app safely holds the action in a queue and retries it once the internet returns, using that same ID so it never creates duplicate records.
• ›The screen updates immediately so users don't have to wait on slow internet, but safely undoes the change if the request completely fails.

As a result, the app completely stopped creating duplicate posts or broken records, allowing people to study smoothly even on weak 3G connections.

§4. Fixing the Look and Feel

When I looked closely at the interface, different screens felt like they had been built by different people without a shared vision. Colors didn't match, button sizes were inconsistent across pages, and meditation articles were crowded with emojis that made reading visually exhausting. Worse, new users who hadn't joined a study plan yet were greeted by a blank white screen with no buttons or advice on what to do next, which made people assume the app was broken and uninstall it right away.

To give the product a welcoming and cohesive feel:

• ›I replaced confusing blank pages with friendly empty states that explain what the screen is for, along with a clear button that guides users to start their first study plan or meditation.
• ›I cleaned up all the random hardcoded colors across the codebase and connected every screen to a shared style guide, while replacing blurry images with crisp vector icons that scale cleanly on any display.
• ›I standardized spacing and typography through the same shared design system and refactored repeated layouts into reusable components, so screens like Community, Profile, and Support finally hang together as one product.
• ›I restructured the layout on daily meditations, adjusted line spacing for readability, and stripped out distracting emojis so users can read peacefully without visual clutter.

Because of these changes, the app now looks like a trustworthy, finished product where new users never get lost on dead screens and daily reading is comfortable on the eyes.

§5. Staying Safe and Keeping the App in the App Stores

Both Apple and Google have strict security and privacy rules to protect users, and they regularly reject or remove apps that fall behind. Our app was running on outdated software foundations, lacked modern authentication methods, and didn't have an in-app button for users to delete their account and personal data—which is now strictly required by store policy and privacy laws.

To keep the app secure, compliant, and in good standing on both stores:

• ›One-Tap Account Deletion: I built a transparent account deletion flow directly into the settings menu, which safely purges a user's personal data and reading history to fully comply with store policies.
• ›Apple and Google Sign-In: I integrated native one-tap sign-in buttons so users can log in seamlessly using Face ID or fingerprint without the headache of remembering passwords.
• ›Secure Release Signing: I managed the complex digital signing upgrades required to keep publishing secure updates to both app stores.
• ›Upgrading the Foundation: I updated the underlying Android and iOS build settings to the latest versions, ensuring the app benefits from modern OS security patches and improved battery efficiency.

Because of this, the app passed all subsequent store reviews with zero rejections or warnings, giving both users and the business complete peace of mind.

§6. Cleaning Up the Codebase

Over time, older codebases inevitably gather clutter like abandoned features, forgotten test files, and outdated code meant for devices we no longer support. All of that accumulated weight made the app heavier, slowed down build times, and made it easy for bugs to slip in whenever developers added new features.

To keep development fast and maintainable:

• ›Throwing Out Dead Code: I audited the repository and removed hundreds of lines of unused code, old broken experiments, duplicate image assets, and outdated remnants from web and desktop platforms we no longer support—all of which were bloating the app.
• ›Automated Quality Checks: I set up automated linting and code quality checks that warn developers before they commit sloppy or slow code, keeping the codebase tidy automatically.

Now, the project builds faster, the codebase is straightforward for any developer to jump into, and our team can ship updates with complete confidence.