Easy Remember
Industry: Productivity and Personal Knowledge Management
Duration: Initial development and release work in September–October 2026; ongoing product development
Project type: In-house product by BezimeniIT
Platforms: React Native application for Android and iOS, with platform-specific native integrations
Overview
Easy Remember began with a familiar frustration: knowing that you saved something useful, but not remembering where to find it.
A tutorial sits in a YouTube playlist. A recipe is saved on Instagram. A screenshot is buried in Photos. A useful website disappears into browser bookmarks. Each app makes saving easy, but the information remains separated—and the reason it mattered is often missing.
BezimeniIT created Easy Remember as its own product to bring those fragments into one personal library. Users can save links, text and images, add context, organize them into topics, and retrieve them through search. Rich notes and optional reminders extend the experience beyond bookmarking.
Led by BezimeniIT founder Milan Popovic, the project covered product definition, cross-platform development, native integrations, interface refinement, testing, monetization and store-release preparation. The first public Android release established the core product, with further development continuing around that foundation.
Challenge
The challenge was not simply to build another place to store links. It was to connect three moments that existing save mechanisms often leave disconnected: capturing something, remembering why it matters, and returning to it later.
That required a workflow fast enough to use while browsing another app, but flexible enough to hold personal notes, images and organization. It also required dependable local storage: a bookmark that loses its context after an interruption is not a useful memory aid.
Cross-platform sharing introduced additional complexity. Android and iOS handle incoming content differently, and a shared JavaScript codebase does not remove those native differences. The experience had to respect each platform while preserving consistent product rules.
The initial work also took place under a tight hackathon deadline. We needed a release sequence that delivered a complete core experience while leaving more ambitious capabilities—such as on-device AI and semantic retrieval—for later development.
Objectives:
- Bring supported links, text, images and personal notes into one searchable library.
- Preserve both the original source and the user’s reason for saving it.
- Make capture, organization and editing consistent across entry points.
- Keep the core library local and usable without creating an account.
- Support recovery through autosave, recent edit history and recoverable removal.
- Build a shared mobile foundation with native integrations where platform behavior demands them.
- Introduce optional paid features without restricting the free saving, editing, organization and search experience.
- Reach a public Android and IOS release and establish a repeatable process for subsequent updates.
Project Requirements:
- Receive a supported link, text selection or image through the system share interface.
- Create notes directly inside the app using the same editor as shared items.
- Retrieve available link titles, descriptions and preview images, with editable user-facing fields and offline fallbacks.
- Organize items into topics and subtopics, allow multiple memberships, and provide importance filters and pins.
- Search saved titles, descriptions, notes and links locally.
- Support headings, lists, interactive checklists and inline images.
- Save edits automatically and retain recent undo/redo history across navigation and app restarts.
- Provide recovery paths for interrupted image imports and unfinished capture preparation.
- Restore removed items, topics and subtopics within the selected retention period.
- Add optional reminders, rediscovery, weekly reviews and biometric app lock through Easy Remember Pro.
- Prepare privacy disclosures, support materials, store assets and review instructions that reflect the actual product.
Solution Overview
We built Easy Remember around a local-first architecture and a shared editing experience. React Native and Expo provided the mobile foundation; focused native integrations handled the parts that could not be treated identically on both platforms.
- One Library, with Personal Context: Saving the source is only part of remembering it. Easy Remember also gives users a place to explain why they cared: “Try this for my next project,” “Recommended by a colleague,” or “Use this recipe at the weekend.”
That context becomes searchable alongside the title, description and link. Users do not need to remember the source application’s name or the exact wording of a page title to find their own recorded clues.
The original link remains distinct from links added later. Editable descriptions and personal notes do not overwrite the original source information. - A Consistent Capture and Editing Experience: Early iterations exposed an important product requirement: creating a note and sharing content into the app should not lead to different sets of editing tools.
We consolidated supported captures into the existing item editor. Whether an item begins as a blank note, a shared link, text or an image, users get the same note formatting, image, link and organization controls.
Newly created items are persisted before subsequent editing. Debounced autosave groups changes into meaningful writes and history entries, avoiding an undo step for every letter. The shared View/Edit preference persists across items, while recent edit history belongs to each item and remains available after reopening the app. - Recognizable Link Previews: An early shared-link title could look like a website name followed by an identifier. It was technically usable but difficult to recognize.
We added metadata retrieval so available titles and descriptions populate the capture experience, with preview images and site icons saved locally. YouTube links, including supported Shorts URLs, use public oEmbed metadata without requiring a secret API key.
Metadata is optional enrichment. An unavailable preview or failed network request does not prevent saving the original link, and users can disable automatic link details. Preview retrieval does not send their private notes. - Native Sharing That Respects Each Platform: Android uses the incoming-share integration to open the capture flow, with handling for cold and warm entry, repeated callbacks and acknowledgement failures.
For iOS, preserving the browsing context required a different approach. We developed a native SwiftUI share extension that opens over the source app. Saving writes an atomic record into an App Group inbox; the main app imports it into SQLite when it next opens or returns to the foreground.
The extension does not open the main library database. This separates the extension’s shorter lifecycle from the main application’s database ownership and allows the user to remain in the source app after saving. - Recovery as Part of the Product: We treated interruption and accidental edits as product concerns, not just error messages.
Image imports record their progress, copy content into app-owned storage and check the copy before treating it as saved. Recovery can reuse a verified local copy or offer a retry when the original temporary permission is no longer available.
Removed content goes to Recently removed. Users can restore it before expiry and choose a retention period, including Never. Removing a topic does not delete the saved items associated with it.
Permanent cleanup needed additional engineering: coordinated database access, bounded batches and durable file-deletion tasks. These keep database changes and later filesystem cleanup recoverable without treating the two as a single atomic operation. - Returning to What Matters: Easy Remember Pro extends retrieval beyond a manual search. It adds reminders for items and topics, recurring schedules, Daily rediscover and a Weekly review of saved but unopened content.
App Lock adds device authentication for opening the library. RevenueCat manages the purchase and entitlement integration for monthly subscriptions and a one-time lifetime option. The core library remains free, with no advertising.
Technological solutions
React Native | Expo | TypeScript | SQLite FTS5 | SwiftUI | RevenueCat | Sentry | EAS
React Native and Expo
A shared Android and iOS application foundation, navigation, development builds and reproducible native configuration. Platform-specific adapters preserve a consistent product model without forcing identical native behavior.
TypeScript and Layered Application Architecture
Domain rules, application workflows, interface hooks and infrastructure adapters have separate responsibilities. This keeps priority calculations, organization and recovery behavior testable independently of screens and vendor SDKs.
SQLite and Local File Storage
SQLite is the source of truth for library content, relationships, preferences and editing history. FTS5 supports local keyword search. Images and preview assets live in app-owned files, referenced through database records rather than embedded as large text payloads.
SwiftUI and App Groups
A native iOS share extension captures content over the source application. An atomic file inbox and shared context snapshot connect the extension to the main app without sharing the active library database connection.
Metadata and Native Device APIs
Public webpage metadata and YouTube oEmbed make saved links recognizable. Native image selection, local notifications and device authentication support editing and Pro features.
RevenueCat
Store offerings, purchases, restoration and entitlement presentation sit behind a dedicated adapter. Purchase networking remains separate from library-content processing.
Sentry and Automated Verification
Crash and error reporting uses privacy filtering and an in-app opt-out. Jest, React Native Testing Library and desktop SQLite integration harnesses exercise product rules, interface behavior, database migrations and recovery boundaries.
EAS and Release Tooling
Signed build workflows, tracked configuration plugins and artifact inspection support repeatable release preparation. Release candidates are tested separately from the public version.
Key Features
Save from Other Apps
Capture supported links, text and images through the native sharing interface, with duplicate-link choices and available preview metadata
Personal Context and Rich Notes
Explain why something matters, write standalone notes, build lists and checklists, and place images within the note.
Flexible Organization
Use topics, subtopics, icons, colors, pins and importance levels. Assign an item to several destinations without duplicating its content. Frequently used topics become easier to reach.
Local Search and Browsing
Search titles, notes, descriptions and links. Browse all saved items, filter by importance, and sort by priority or save date.
Autosave, Undo and Recovery
Keep recent edit history across sessions, restore removed content before expiry, and resume supported interrupted capture and image-import operations.
Optional Pro Features
Set item and topic reminders, revisit older saves through Daily rediscover, review unopened content, and enable biometric or passcode-based App Lock.
Implementation
The project progressed from an Expo starter to a public Android product through small, testable increments. The first release focused on a complete save–organize–find workflow, with the richer editor, recovery paths, onboarding and settings developed around it.
A later interface redesign introduced a shared visual system while retaining platform-specific navigation, icons and controls. Library lists and topic inventories were paginated in groups of 30, and returning to an already-loaded list was refined to preserve visible content during refresh.
Store preparation included production signing, internal distribution, physical-device feedback, permission review, privacy and Data safety materials, support pages, store artwork and a product demonstration. iOS review preparation also required clear explanations of the app’s purpose, external services, testing steps and paid functionality.
Android delivery reached a public Google Play release. In parallel, the iOS work established the native share extension and platform-specific experience within the shared application foundation.
Explore Easy Remember · View on Google Play · View on Apple Store · Watch the demo
Development Process
Planning & Gaining Clarity
We started with concrete situations: saving a tutorial, keeping a screenshot with a note, writing an idea, and finding information from a remembered phrase. These scenarios shaped the product rules and acceptance cases.
The wider vision included local AI and more specialized content workflows. We deliberately separated that roadmap from the release requirements. Reliable capture, editing and retrieval needed to stand on their own before more advanced processing could add value.
Solution Design
We chose one authoritative local database, durable attachment storage and explicit boundaries around sharing, metadata, purchases and authentication.
Several decisions came directly from the intended experience: editable descriptions must not destroy fetched metadata; subtopic membership must not silently imply parent membership; undo history must survive navigation; and topic removal must preserve saved items.
These rules informed the data model and transactions before they became interface details.
Agile Development
Development followed short implementation-and-review cycles, with hands-on feedback informing the next increment.
That feedback changed the product in specific ways: metadata titles appeared before editing began; manual notes gained the same image tools as shared items; formatted lists continued naturally on Enter; checkboxes became interactive; inline images appeared in both View and Edit; and the return-to-View action became directly accessible beside Undo/Redo.
The redesign followed the same principle: improve presentation and platform fit while preserving established content and workflow behavior.
Testing & Deployment
Testing covered pure rules, application services, interface behavior and repository operations. File-backed desktop SQLite checks exercised migrations, reopen behavior, rollback and recovery using synthetic data. Native and store flows remained separate checks, requiring real builds and device testing.
Real-device investigation also exposed issues that ordinary interface tests could not prove. An iOS lifecycle crash was traced through native logs and a symbolicated stack to database teardown involving FTS5 statements. We changed database ownership to a process-lifetime connection and added regression coverage for its lifecycle.
After the initial Android release, an optimized candidate revealed another native boundary: resource shrinking removed a string used dynamically by incoming sharing. Artifact comparison identified the missing resource, and a targeted keep rule was added. This reinforced the need to inspect and test the actual release candidate, not just the development app.
Post-Launch Support
Post-launch work continued with release optimization, share-flow investigation, clearer product communication and supporting website materials.
The architecture keeps future work possible without presenting it as already shipped. Export/import, semantic search, automatic organization and on-device summaries remain distinct roadmap items with their own implementation and verification needs.
Results
Easy Remember progressed from a product idea to a publicly released Android and iOS application in just 2 weeks, supported by a cross-platform codebase and a native iOS sharing implementation.
A complete core workflow: Users can capture supported content, add personal context, organize it and find it locally in the same product.
A consistent editing model: Manual notes and shared content use the same tools, reducing differences between capture paths.
Local-first product ownership: The library does not require an account or an app-operated content server. Optional metadata, diagnostics and billing have separate, disclosed network roles.
Recovery built into the experience: Autosave, retained edit history, recoverable removal and supported import-recovery paths address common ways users lose work.
An optional commercial model: Pro adds reminders, rediscovery and App Lock while keeping the core saving and retrieval workflow free.
An evidence-based development foundation: Automated checks, real SQLite harnesses, native logs and release-artifact inspection provide different layers of verification. At the documented October 2 checkpoint, the project passed 673 Jest tests across 108 suites, plus 14 release-tool tests; these are engineering results, not adoption or reliability guarantees.
The result is an owned product with a working commercial foundation and a clear path for continued iteration around real user feedback.
Conclusion
Easy Remember demonstrates BezimeniIT’s approach to building its own products: start with a recognizable problem, define the behavior carefully, and carry the work through design, implementation, recovery, testing and release.
The visible product is a personal library. The engineering behind it spans native sharing, local persistence, editing history, platform-specific UX, privacy boundaries and store integration.
By keeping the first release focused and treating real-device feedback as part of development, we established a product that can grow without confusing future ambition with present functionality.
Easy Remember: save what matters, find it when it matters.
Want to Know More?
Explore Easy Remember and watch the demo to see the product in use.
Have an app idea or an existing product that needs a stronger technical foundation? BezimeniIT helps founders turn product requirements into working mobile software—from architecture and native integrations to testing and store-release preparation.
Contact us at sales@bezimeniit.com.