Skip to main content

Comprehensive App Performance Metrics for Rezio's AI Real Estate Assistant

1. User Engagement Metrics​

Daily Active Users (DAU)​

Definition: The number of unique users who engage with the app on a given day.
Example: If 1,000 unique users open and interact with the app on Monday, the DAU for Monday is 1,000.
Measurement Approach:

  • Use Firebase Analytics to track unique user logins and app opens per day.
  • Set up a daily cron job in Django to aggregate this data from Firebase.

Monthly Active Users (MAU)​

Definition: The number of unique users who engage with the app within a 30-day period.
Example: If 5,000 unique users interacted with the app at least once in July, the MAU for July is 5,000.
Measurement Approach:

  • Use Firebase Analytics to track unique user interactions over a rolling 30-day period.
  • Create a Django management command to pull this data monthly and store it in PostgreSQL for trend analysis.

Session Duration​

Definition: The average length of time users spend in the app per session.
Example: If users typically spend 15 minutes in the app each time they open it, the average session duration is 15 minutes.
Measurement Approach:

  • Implement session tracking in Flutter using custom analytics events.
  • Send start and end session events to Firebase Analytics.
  • Use a Django script to calculate average durations from the Firebase data.

Retention Rate​

Definition: The percentage of users who return to the app after their first visit within a specific timeframe.
Example: If 100 new users download the app on Monday, and 40 of them use it again within 7 days, the 7-day retention rate is 40%.
Measurement Approach:

  • Use Firebase Analytics to track new user acquisitions and their subsequent app opens.
  • Create a Django view that queries this data and calculates retention rates for 1-day, 7-day, and 30-day periods.

2. Performance Metrics​

App Load Time​

Definition: The time it takes for the app to become fully interactive after a user launches it.
Example: If it takes 2 seconds from tapping the app icon to being able to interact with the main screen, the app load time is 2 seconds.
Measurement Approach:

  • Implement custom timing events in Flutter to measure the duration between app launch and the main screen becoming interactive.
  • Send these timing events to Firebase Analytics.
  • Use a Django script to periodically fetch and analyze this data, storing summaries in PostgreSQL.

API Response Times​

Definition: The time it takes for the backend to respond to various API requests from the mobile app.
Example: If a property listing API call typically takes 200ms to return data, that's the API response time for that endpoint.
Measurement Approach:

  • Implement timing middleware in Django to measure the duration of each API request.
  • Log these timings to AWS CloudWatch.
  • Create a Django management command to fetch CloudWatch logs, analyze response times, and store summaries in PostgreSQL.

Error Rates​

Definition: The percentage of app operations or API calls that result in errors.
Example: If 5 out of 1000 API calls result in a 500 error, the error rate for that API is 0.5%.
Measurement Approach:

  • Implement error tracking in both Flutter (for client-side errors) and Django (for server-side errors).
  • Send error events to Firebase Crashlytics and AWS CloudWatch.
  • Create a Django dashboard that aggregates error data from both sources and calculates rates.

3. User Satisfaction Metrics​

App Store Ratings​

Definition: The average rating users give the app on the App Store and Google Play Store.
Example: If the app has an average of 4.5 stars out of 5 on both stores, that's the App Store Rating.
Measurement Approach:

  • Use a third-party service like AppFollow to track ratings across both stores.
  • Implement a webhook in Django to receive rating updates and store them in PostgreSQL.

In-App Feedback Score​

Definition: A rating system within the app where users can quickly rate their experience after completing key actions.
Example: After a user completes a property negotiation, prompt them to rate the experience from 1 to 5 stars.
Measurement Approach:

  • Implement custom rating prompts in Flutter after key user actions.
  • Send these ratings to Firebase Analytics.
  • Create a Django view that fetches this data, calculates averages, and presents trends over time.

4. Technical Metrics​

App Crash Rate​

Definition: The percentage of app sessions that end in a crash.
Example: If 10 out of 1000 app sessions end in a crash, the crash rate is 1%.
Measurement Approach:

  • Use Firebase Crashlytics to automatically detect and report app crashes.
  • Create a Django script that fetches crash data from Crashlytics API, calculates rates, and stores them in PostgreSQL.

Backend Error Rate​

Definition: The percentage of API requests that result in server errors (5xx status codes).
Example: If 20 out of 10,000 API calls result in a 500 error, the backend error rate is 0.2%.
Measurement Approach:

  • Implement logging middleware in Django to capture all API responses.
  • Store logs in AWS CloudWatch.
  • Create a Django management command to analyze CloudWatch logs, calculate error rates, and store summaries in PostgreSQL.

5. Feature Usage Metrics​

AI Assistant Interaction Rate​

Definition: The percentage of app sessions that include at least one interaction with the AI assistant.
Example: If 800 out of 1000 daily sessions include users chatting with the AI, the AI Assistant Interaction Rate is 80%.
Measurement Approach:

  • Implement custom events in Flutter to track when users start a conversation with the AI.
  • Send these events to Firebase Analytics.
  • Create a Django view that calculates the percentage of sessions with AI interactions on a daily and weekly basis.

Automated Negotiation Usage​

Definition: The number of times users allow the AI to handle negotiations automatically.
Example: If users opt to let the AI handle negotiations 500 times in a week, that's the weekly Automated Negotiation Usage.
Measurement Approach:

  • Track automated negotiation initiations as custom events in Flutter.
  • Send these events to Firebase Analytics.
  • Create a Django dashboard that fetches this data and presents daily, weekly, and monthly usage trends.

Conclusion​

These metrics provide a comprehensive view of the app's performance, focusing on user engagement, technical performance, and feature usage. By tracking these metrics, management can gain insights into:

  1. How often users are engaging with the app
  2. The app's technical performance and stability
  3. Which features are most popular and useful
  4. Overall user satisfaction

Regular monitoring and analysis of these metrics will allow for data-driven decisions on feature development, performance optimization, and user experience improvements. It's recommended to set up automated weekly or monthly reports using Django's reporting capabilities, pulling data from Firebase Analytics, AWS CloudWatch, and your PostgreSQL database to provide management with ongoing insights into the app's performance and growth.