• User authentication (sign in and sign up) requesting Uniandes email and additional students data.
• Add a product for sale with its respective information using the phone's camera sensor and accessing the photo gallery.
• List of available products with their respective details (name, description, images and seller).
• Personalized filter recommendations by category based on user searches and clicks.
• Efficient product search based on product name and description.
• Personalized notifications when a user's favorite product drops in price.

• Product recommendations during key periods of university.
• Profile page with routes to favorite products and products published by the user with the option to edit or delete that product.
• List of the user's favorite products.
• Chat page for communication between seller and buyer of a product.
• Personalized notifications to inform the user about updates on active listings.

• View the seller's profile and rate them after a completed transaction.
• Complete the purchase of a product.
• Adds a second authentication step by sending a time-limited code to the user’s Uniandes email (OTP) for verify login.
• Personalized notifications to inform the user about new messages on a chat.
• Return process for sold products that do not match the specifications listed in the app.

SeneMarket is a university exclusive marketplace designed to support both students and certified campus vendors by providing a structured and reliable platform for buying and selling a wide variety of products, from academic materials to snacks, desserts, phone cases, and more. It promotes a circular economy and waste reduction. Leveraging its context-aware smart features, the platform adapts to the university calendar, prioritizing exam materials during exam weeks and academic supplies. Additionally, it optimizes product visibility based on time-of-day patterns, promoting food vendors during peak meal times and class transitions to maximize convenience for buyers and sellers. By ensuring a secure and trusted environment with verified university-affiliated sellers, SeneMarket enhances accessibility, boosts small student-led businesses, and fosters a dynamic, campus-focused economy tailored to the real-time needs of the community—offering a trusted, cost-effective, sustainable, and user-friendly solution tailored to the academic community’s needs.

Moreover, SeneMarket suggests personalized filters for each user based on past searches and surfaces trending products by analyzing click activity, in-app chats, and academic-week sales data (for example, identifying which semester week sees the highest demand for supplies in a specific program). It also tracks the influence of chat interactions on purchase decisions to continuously refine the platform. Users can create new product listings, add items to favorites, and edit their products or profile. Favorite items are accessible offline and users receive notifications when a favorite product’s price drops. To minimize the impact of connectivity issues on the user experience, core functions—such as browsing saved listings, drafting new offers, and accessing favorites—remain fully operational even without internet. Our revenue model combines non-intrusive in-app advertising, voluntary donations from supportive students, and optional premium listings that boost sellers’ visibility.

No. 11 Type 4 business question was changed since the one defined in Sprint 1 was not convenient since we have only one category per product.

This section documents key micro-optimization strategies applied to improve performance in the Senemarket Flutter app. These include UI rebuild reduction, resource-efficient widget reuse and smarter data handling.

Before / after code examples

Each example below shows how the code was improved through a specific micro-optimization strategy.

1. Memoization / caching for heavy logic

Before

final filtered = products.where((p) => matches(p, selectedFilters)).toList();

After

List<Product>? _cachedFiltered;
List<Product> getFiltered(List<Product> products) {
  if (_cachedFiltered != null) return _cachedFiltered!;
  _cachedFiltered = products.where((p) => matches(p, selectedFilters)).toList();
  return _cachedFiltered!;
}

2. Debounce search inputs

Before

onChanged: (text) => viewModel.updateSearchQuery(text),

After

Timer? _debounce;
onChanged: (text) {
  if (_debounce?.isActive ?? false) _debounce!.cancel();
  _debounce = Timer(const Duration(milliseconds: 400), () {
    viewModel.updateSearchQuery(text);
  });
},

3. Minimal and grouped setState calls

Before

setState(() => _name = value);
setState(() => _email = value);

After

setState(() {
  _name = value;
  _email = value;
});

4. Use of const for static widgets

Before

Text('Hello'),
Icon(Icons.person),

After

const Text('Hello'),
const Icon(Icons.person),

5. Provider.of(context, listen: false)

Before

final user = Provider.of<UserProvider>(context);

After

final user = Provider.of<UserProvider>(context, listen: false);

7. Replace var with late final

Before

var userId = FirebaseAuth.instance.currentUser!.uid;

After

late final String userId = FirebaseAuth.instance.currentUser!.uid;

Conditional loading in _loadUserData

Before

final data = await repo.getUserData();
setState(() {
  name = data['name'];
  // ...
});

After

if (shouldReloadUserData) {
  final data = await repo.getUserData();
  setState(() {
    name = data['name'];
    // ...
  });
}

Performance before and after implementing micro-optimization strategies

This section visualizes the measurable impact of the applied micro-optimizations. All tests were run on a emulator and Flutter DevTools performance tab.

A system trace profiling test was made. This was the results:

Based on these results we conclude:

By leveraging I/O dispatchers, the application effectively distributes computational tasks across multiple threads. This approach prevents blocking the main thread, thereby mitigating the risk of Application Not Responding (ANR) errors. The strategic use of threading ensures responsive user interactions and smooth background processing.

The integration of Firebase and Glide caching libraries plays a crucial role in optimizing memory consumption. These technologies intelligently cache data and resources, significantly reducing redundant network requests and minimizing unnecessary object creation. This approach not only improves performance but also enhances the application's memory efficiency.

While the current implementation demonstrates strong performance characteristics, continuous monitoring and incremental improvements can further enhance the application's efficiency.

Considering the essential role of local storage in managing on-device data, its implementation is key to ensuring that, in scenarios of network unavailability, the application can continue functioning without disrupting the user experience. By maintaining access to critical data offline, the app guarantees continuity of its core functionalities under varying connectivity conditions.

The selection of local storage strategies was guided by the specific characteristics and persistence requirements of each data type. This alignment allowed for the adoption of the most suitable data structures (ranging from key-value stores to relational databases and secure storage) optimizing performance, reliability and scalability.

This deliberate approach not only simplified CRUD operations, but also ensured that stored data remained easily accessible and seamlessly integrated within the app’s runtime logic. As a result, performance was enhanced, data integrity was preserved and the overall responsiveness of the application was maintained.

The following table presents the local storage strategies implemented across different features, outlining what is stored, the rationale behind its storage and the corresponding storage mechanism used.

In the Kotlin implementation of SeneMarket, Room serves as the primary local storage solution for structured and queryable data such as chat messages, return requests, and user-related information. Room abstracts the complexities of SQLite, providing type safety and compile-time query verification, which enhances both reliability and developer productivity.

For lightweight and key-value storage, SharedPreferences and EncryptedSharedPreferences are used. SharedPreferences stores non-sensitive flags and timestamps (e.g., last sync time or submission status), while EncryptedSharedPreferences securely handles sensitive user data such as credentials or personal preferences.

This hybrid local storage strategy enables the app to deliver a responsive, offline-first experience. Data like unread messages and product return requests can be stored and accessed locally, allowing users to continue interacting with key features even when internet connectivity is limited. Upon reconnection, the app synchronizes with Firebase, ensuring consistency and real-time updates across devices.

The following table summarizes how local storage is leveraged to support critical features in the app:

In Flutter, concurrency plays a fundamental role in maintaining a responsive and performant user interface by allowing asynchronous operations to execute without blocking the main UI thread. Although Flutter apps run in a single-threaded environment by default, Dart provides several mechanisms for managing concurrent tasks effectively.

The multi-threading/concurrency strategy chosen for each feature was based on:

• The nature and duration of the task.
• The need for real-time updates.
• The potential impact on performance or responsiveness.
• The ability to recover in the presence of delays, retries or background processing.

Below are the main concurrency mechanisms used in the app.

In Kotlin, concurrency is essential for delivering a responsive user experience, especially in mobile environments where tasks like network requests, local storage operations, and UI updates must coexist efficiently. Kotlin provides several tools for managing concurrency, primarily through coroutines, which allow asynchronous tasks to run without blocking the main UI thread.

The strategy for each feature was chosen based on:

• The nature and expected duration of the task.
• The need for responsiveness or real-time updates.
• Whether the operation could continue or resume under intermittent connectivity.
• The ability to handle background processing or retries safely.

Below is a breakdown of the concurrency strategies used in the Kotlin implementation for key features:

Seller Profile Image Caching with cached_network_image

A caching approach that fetches the seller’s avatar from the network and stores it locally on the device to prevent redundant downloads and accelerate load times.

To optimize performance and minimize data usage, SeneMarket applies this mechanism to seller profile pictures using the cached_network_image plugin backed by flutter_cache_manager. Once an avatar is downloaded, it’s instantly available on subsequent views.

Libraries used

• cached_network_image: Loads and displays images from the network with automatic caching.
• flutter_cache_manager: Provides advanced file caching management; used internally by cached_network_image and extended here for profile images.

Modified and added files for profile image caching

With this setup, seller profile images load faster and consume less data, delivering a consistently improved user experience across the app.

Efficient caching is vital for optimizing performance and ensuring a smooth user experience, especially in apps with intermittent connectivity or frequent content updates. In SeneMarket’s Kotlin implementation, we leverage Room for structured local data caching and Glide for image caching. These tools reduce redundant network requests, accelerate UI load times, and support offline access to essential data.

Personalized Notifications for New Messages

What is cached:

• Last read message ID
• List of recent messages from active chats

Why it's cached: To avoid re-fetching entire message histories when checking for new messages. Only unread messages are fetched from the server, reducing network load and speeding up notifications.

Caching strategy:

• Room Database stores chat metadata and message IDs locally.
• Repository pattern checks local cache before querying the network.
• Cache is updated when connectivity is available, with fallback to local data if offline.

Libraries used:

• Room: For structured caching of message and notification data.
• Coroutines + ViewModelScope: To asynchronously manage cache refresh without blocking the UI.

Return Process for Sold Products

What is cached:

• Return request data (reason, product ID, timestamp, image proof)
• Submission status (pending/synced)

Why it's cached: Allows users to initiate return requests while offline. The data is stored locally and synced when the network is available, ensuring reliability and user trust.

Caching strategy:

• Room Database stores return requests locally.
• WorkManager retries syncing in the background.
• The app shows locally cached request status to inform the user of progress.

Libraries used:

• Room: For persistent caching of structured return data.
• WorkManager: For background syncing of cached requests.
• EncryptedSharedPreferences: Used to store secure flags (e.g., user authentication tokens for syncing).

With these caching strategies, SeneMarket ensures real-time responsiveness and seamless functionality even in low connectivity scenarios while minimizing data usage and supporting a more sustainable mobile experience.

https://drive.google.com/file/d/1fCfm15gpXR5k38QtBjpMTcGicm2s-jQi/view?usp=sharing