Requirements

Imagine you're building a user activity tracking system for a mobile application. The goal is to capture various user activities within the app (e.g., screen views, button clicks, purchases, search queries) and persist them for later analysis. This tracking system should be robust, efficient, and easy to extend with new activity types without requiring major code changes. We want to avoid sending redundant data and minimize battery drain while capturing useful user behavior. This problem focuses on the core in-app tracking mechanism and its storage, not the backend infrastructure for receiving and processing the data. We assume a simplified persistence layer (e.g., in-memory, local file storage) for demonstration purposes. # Requirements ## Functional Requirements 1. **Track Different Activity Types:** The system must be able to track different types of user activities, including: * Screen Views: Record when a user navigates to a specific screen (e.g., "HomeScreen", "ProductDetailsScreen"). Include screen metadata (e.g., screen name, screen ID, parent screen). * Button Clicks: Record when a user clicks a button or interactive element. Include button metadata (e.g., button name, button ID, target URL/action). * Search Queries: Record when a user performs a search. Include the search query string. * Purchase Events: Record when a user completes a purchase. Include purchase details (e.g., product ID, quantity, price). * Custom Events: Allow for tracking of custom events with arbitrary data (e.g., event name, key-value pairs of event properties). 2. **Activity Metadata:** Each activity should be recorded with a timestamp, user ID, and device information (e.g., device model, OS version). 3. **Buffering and Batching:** The system should buffer activities in memory and periodically persist them in batches to avoid excessive I/O operations and minimize battery consumption. The batch size and flush interval should be configurable. 4. **Persistence:** The system must persist the activities to a local storage (e.g., a file or in-memory store). Assume local storage operations are relatively slow. 5. **User Session Management:** The system should automatically start a new session when the app is launched and end the session when the app is terminated. Session information (session ID, start time, end time) should be included in each activity record. 6. **Configuration:** Provide a mechanism to configure the tracking system (e.g., enable/disable tracking, set batch size, flush interval, configure which activity types to track). 7. **Sampling:** Implement a sampling mechanism to only track a percentage of activities (e.g., track 50% of button clicks, 20% of screen views). This is useful for managing data volume and costs. 8. **Offline Support:** The system must continue to track activities even when the device is offline. Activities should be persisted locally and uploaded when the device reconnects to the internet (assume the re-connection part is handled by a separate service, we just need to ensure that local storage continues to function). 9. **Error Handling:** The system should gracefully handle errors during activity tracking and persistence. Errors should be logged, but should not crash the application. ## Non-Functional Requirements 1. **Extensibility:** The system should be designed to easily support new activity types without requiring modification of existing code. Use appropriate design patterns to achieve this. 2. **Modularity:** The system should be divided into well-defined modules with clear interfaces. 3. **Thread Safety:** The activity tracking and persistence mechanisms must be thread-safe to avoid data corruption in multi-threaded environments. Consider concurrency issues during buffering and flushing. Specifically, multiple threads might be adding activities to the buffer concurrently and a separate thread might be flushing the buffer. 4. **Testability:** The system should be designed to be easily testable. Use dependency injection to allow for mocking of dependencies during unit testing. 5. **Performance:** The system should minimize the impact on application performance. Activity tracking should be non-blocking and should not introduce noticeable latency. Pay attention to memory consumption, especially when buffering activities. 6. **Resource Efficiency:** Minimize battery drain by buffering activities and batching persistence operations. 7. **Configuration Management:** Configuration changes should be applied dynamically without requiring application restarts. 8. **Maintainability:** The code should be well-documented and easy to understand. ## Core Entities 1. **Activity:** Represents a single user activity. It is an abstract class or interface with subclasses for different activity types (ScreenViewActivity, ButtonClickActivity, SearchQueryActivity, PurchaseEventActivity, CustomActivity). 2. **ActivityTracker:** The main class responsible for tracking activities. It provides methods for recording different types of activities. 3. **ActivityBuffer:** A buffer that stores activities in memory before they are persisted. It should handle concurrent access from multiple threads. 4. **ActivityPersistence:** An interface or class responsible for persisting activities to local storage. 5. **ActivitySerializer:** An interface or class responsible for serializing activities into a format suitable for persistence (e.g., JSON). 6. **ConfigurationManager:** Manages the configuration of the tracking system (e.g., batch size, flush interval, enabled activity types). 7. **UserSession:** Represents a user session. Stores session ID, start time, and end time. 8. **SamplingStrategy:** An interface defining a strategy for sampling activities. Different implementations can be used for different activity types (e.g., sample 50% of button clicks).

Design a user activity tracking system for user on mobile.

Requirements

Interview Simulation

Functional Requirements

💡 Interview Tip

Non-Functional Requirements

Core Entity Identification

Premium Content