We've all been there — a beloved houseplant quietly withering because we forgot to water it for a week. That simple frustration is the perfect seed for a plant diary app idea.
The good news: you can build a fully functional prototype with Rork in just a few hours. Even the combination of photo capture, watering logs, and push notification reminders — which sounds complex — comes together surprisingly quickly with the right prompts. This tutorial walks through every step from zero to a working app.
What We're Building
The app is called "Green Friends," a plant management tool with four core features.
- Plant registration: Add a name, plant type, and photo
- Watering log: One-tap logging with elapsed days since last watering displayed
- Growth timeline: A photo journal sorted by date
- Reminder notifications: Scheduled push notifications — no server required
This feature set hits an ideal difficulty level for practicing with Rork. You'll learn camera access, local data storage, and local notifications — three foundational patterns that apply to dozens of other app categories.
Step 1: The Plant List Screen and Registration Form
Start by generating a list screen and a form to add plants. Paste this prompt into Rork:
Create a plant management app called "Green Friends."
The main screen shows a card list of registered plants.
Each card displays the plant's photo, name, and "Last watered X days ago."
Tapping the "+" button in the top-right opens a plant registration form with these fields:
- Plant name (text input)
- Plant type (Cactus / Succulent / Houseplant / Flowering plant / Other)
- Photo (camera capture or photo library picker)
- Watering frequency (Every day / Every 2 days / Weekly / Every 2 weeks)
Save all data to local storage using AsyncStorage.
This single prompt generates the list screen, registration form, and AsyncStorage persistence together. Preview it in the Rork Companion app and you should see a card-based main screen.
If photos aren't displaying correctly, try: "Check the image URI storage format and ensure the local URI from expo-image-picker is stored directly in AsyncStorage without transformation."
Step 2: Watering Log Functionality
Now add one-tap watering tracking to each plant card.
Add the following features:
1. A "Water 💧" button to each plant card
2. Tapping the button saves the current date and time as a watering record
3. Show elapsed days since last watering as "X days ago"
4. Calculate "Next watering in: X days" based on the plant's watering frequency
5. Highlight cards in red when watering is overdue
Save the full watering history for each plant.
The date math behind this is straightforward — the generated code will look something like this:
// Calculate days since last watering
const getDaysAgo = (lastWateredDate) => {
const now = new Date();
const last = new Date(lastWateredDate);
const diffMs = now - last;
// Convert milliseconds to whole days
return Math.floor(diffMs / (1000 * 60 * 60 * 24));
};
// Calculate days remaining until next watering
const getDaysUntilNextWatering = (lastWateredDate, frequencyDays) => {
const daysAgo = getDaysAgo(lastWateredDate);
return Math.max(0, frequencyDays - daysAgo);
};When getDaysUntilNextWatering returns 0, the plant needs water. Rather than a full red card background, a red left border tends to feel more polished — try: "Instead of a full red card, add a thick red left border to plants that need watering."
Step 3: Growth Timeline
Add a photo timeline so users can track how their plants grow over time.
Create a detail screen for each plant with the following additions:
1. An "Add growth record" button that saves a photo and optional note
2. A timeline of all growth records sorted newest-to-oldest
3. A "Photo grid" tab showing all photos in a 3-column layout
4. A "Before & After" view comparing the oldest and most recent photos
The timeline is what keeps users coming back. Scrolling through months of growth photos and seeing a small seedling turn into a thriving plant is genuinely satisfying — and that emotional payoff drives long-term retention far better than any gamification mechanic.
Step 4: Push Notification Reminders
Finally, add scheduled reminder notifications. We'll use local notifications — no backend server needed.
Add watering reminder notifications to each plant's detail screen.
1. Add a "Set Reminder" button to the detail screen
2. Tapping it opens a time picker (hour and minute)
3. Schedule repeating notifications based on the plant's watering frequency
4. Notification text: "[Plant Name] needs water 💧"
5. If notification permission hasn't been granted, show a permission request dialog
Use expo-notifications for local notifications (no server required).
The generated code will include permission requests, scheduling, and cancellation. Since local notifications don't work in the iOS simulator, use the Rork Companion app for real device testing. That first notification arriving on your actual iPhone is a satisfying milestone.
For a deeper dive into notification patterns, see the expo-notifications Local Notifications Complete Guide.
Common Issues and Fixes
A few things tend to trip people up during this build.
Photos load slowly or fail to display: Add "Use the expo-image library to optimize image caching" to your prompt. The expo-image component handles caching significantly better than the default Image component.
Data disappears on app restart: This is a timing issue with data loading. Try: "Fix data loading to read from AsyncStorage inside useEffect with an empty dependency array so it runs on mount."
Notifications not arriving: Expo Go has restrictions on local notifications. Use the Rork Companion app or a development build via EAS for reliable real-device testing.
Next Steps
Building the Green Friends plant diary gave you hands-on practice with three patterns — camera, local storage, and notifications — that you'll use again and again across different app ideas. The data persistence logic from this tutorial transfers directly to habit trackers, reading logs, journal apps, and more.
Once your app is polished, the logical next step is submitting to the App Store. Check out How to Publish Your Rork App to the App Store for a step-by-step walkthrough.
If you want to take the plant theme further — adding AI camera diagnosis to identify plant diseases or deficiencies — Rork AI Camera Plant Care Diagnosis App Guide covers the more advanced implementation.
Polishing the UI: Making It Feel Like a Real App
A working prototype is satisfying, but there's usually a gap between "functional" and "something you'd actually want to use every day." A few targeted prompts can close that gap quickly.
Card design: The default card styling Rork generates tends to be clean but generic. To match the natural, calming feel a plant app should have, try: "Redesign the plant cards with a soft green color palette. Use rounded corners with radius 16, add a subtle drop shadow, and choose a botanical-inspired font for the plant name."
Empty state: When users first open the app, an empty list with no plants registered can feel cold and uninviting. Add an illustrated empty state: "When there are no plants registered, show a centered illustration of a small potted plant with the message 'Add your first plant to get started 🌱' and a large green button."
Watering confirmation animation: A small celebratory animation after tapping "Water" reinforces the behavior you want to encourage. Try: "After tapping the water button, show a brief animation — a water droplet icon falling into the plant — before updating the last-watered timestamp."
These small touches don't require much effort in Rork, but they make a disproportionate difference in how the app feels. The goal isn't to overengineer — it's to make the daily interaction feel rewarding enough that users actually open the app and log their watering.
Thinking About Data Over Time
One thing worth planning early: how you store watering history affects what you can show users later. A flat timestamp array is fine for basic functionality, but if you also store weather or season data alongside each watering event, you open up interesting long-term insights.
For example: "Store the current temperature (from a public weather API) alongside each watering record, so users can later correlate watering frequency with seasonal changes." This kind of small architectural decision, made early, unlocks features that would otherwise require a data migration later.
If you eventually want to sync plant data across devices — so users can access their plant logs on an iPad or share with a family member — you'll want to move from AsyncStorage to a cloud backend. Supabase Auth and Realtime Guide for Rork covers the migration path from local-only to cloud-synced data.
The Broader Pattern: Building Small Apps That Stick
The plant diary tutorial is deliberately simple, but it illustrates something important about app design: the apps people use daily are often not the most technically impressive ones. They're the ones that solve a small, concrete problem in a frictionless way.
Water my plants. Track my runs. Log what I eat. Remember what I read. None of these require machine learning or real-time collaboration. They require reliable data persistence, sensible notifications, and a UI that doesn't get in the way.
As you move beyond this tutorial, the same three-feature pattern — data entry, storage, notification — scales to dozens of categories. The next app you build might be a medication reminder, a gym log, or a habit tracker. The Rork prompting skills you developed here transfer directly.
Pick one of those ideas, open Rork, and start with the same structure: a list screen, a registration form, and a log action. You'll have a working prototype faster than you expect.