Bookmarked Android: A Simple Viewer for My Bookmarked Content
A performant, zero-bloat native Android client engineered with Jetpack Compose, Kotlin Coroutines, and Room Database to deliver distraction-free article reading on resource-constrained devices. Features background synchronization via WorkManager, smart tag categorization, offline caching, and responsive typography.
Project Overview
This project started as a simple frustration with my underpowered phone. I wanted to read bookmarked articles without the bloat of traditional news apps, so I built a native app using Jetpack Compose that prioritizes speed and minimalism.
The Problem
Most bookmarking and reading apps are heavy on resources. They load unnecessary trackers, ads, and have bloated UIs. On a budget Android phone with 2GB RAM, most apps would freeze or take forever to load. I needed something that just worked.
Stock Android phones with limited RAM struggle with heavy apps. This was the core motivation behind building Bookmarked Android.
Solution
I built Bookmarked Android with performance as the primary goal from day one. Using Jetpack Compose's declarative approach, I created a streamlined interface that fetches bookmarks efficiently and renders them with minimal overhead.
Key Features
- Zero-Bloat Reader: Clean, distraction-free reading interface with adjustable fonts and themes
- Instant Sync: Fetches your bookmarks in the background without blocking the UI
- Offline Mode: Download and read articles offline, perfect for commutes
- Smart Categories: Auto-categorize bookmarks using simple ML tags
- Dark Theme: Eye-friendly dark mode for night reading
- Search: Lightning-fast search through thousands of bookmarks
Technical Implementation
Architecture
- Clean Architecture: Separation of UI, domain, and data layers
- MVVM Pattern: ViewModel for lifecycle management and state handling
- Repository Pattern: Abstracted data access for easy testing
Technologies
- Kotlin: Modern, concise, and safe language for Android
- Jetpack Compose: Declarative UI framework for rapid development
- Room Database: Local SQLite database for offline access
- Retrofit: Type-safe HTTP client for API calls
- Coroutines: Asynchronous programming for smooth performance
- DataStore: Secure preferences storage for user settings
Performance Optimizations
- Lazy loading of article previews
- Image compression and caching
- Efficient database queries with proper indexing
- Background syncing using WorkManager
Challenges & Solutions
Challenge 1: Memory Constraints
On devices with limited RAM, loading large articles caused OutOfMemoryErrors. We solved this by implementing lazy loading and streaming large content chunks.
1// Efficient memory management with lazy loading2class ArticleViewModel : ViewModel() {3 private val articleRepository = ArticleRepository()45 fun loadArticlesLazily() {6 viewModelScope.launch {7 articleRepository.getArticlesPaginated(pageSize = 20)8 }9 }10}
Challenge 2: Network Reliability
Bookmarks wouldn't sync on unstable connections. We implemented exponential backoff retry logic with local queue management to ensure no data loss.
Challenge 3: Database Performance
Query times were slow with thousands of bookmarks. We added proper database indexing and pagination to keep the UI responsive.
Database indexing reduced query times from 2 seconds to 50ms for large datasets.
Results & Impact
- Reduced memory footprint to under 30MB
- Average load time: < 500ms for bookmark list
- 4.8★ rating on Google Play with 5K+ users
- 95% offline functionality for saved articles
Lessons Learned
- Performance testing should happen early and often
- Local-first architecture is powerful for mobile apps
- User feedback is invaluable for feature prioritization
- Simple UIs often outperform complex ones
- Coroutines are essential for smooth Android development
Future Roadmap
- Integration with other bookmarking services (Pocket, Raindrop)
- AI-powered summary generation
- Voice notes for bookmarks
- Cross-device sync using backend
- Widget for quick access on home screen