Solution Overview:

LeafLog is a specialized software solution meticulously crafted to elevate the experiences of plant enthusiasts through a robust architectural design. Our system is engineered to seamlessly manage a comprehensive plant database, ensuring efficient retrieval of information on various species, environments, and care techniques. The architecture prioritizes scalability to accommodate a growing community of users, allowing for easy integration of new features and updates. LeafLog's intuitive interface and personalized plant journals are backed by a well-structured database and efficient algorithms, providing users with a fluid and responsive experience. The platform's architecture also facilitates real-time notifications and reminders, enhancing user engagement and plant care adherence. Overall, LeafLog's software architecture is intricately designed to deliver a seamless, scalable, and enriching experience for plant enthusiasts.

Application Nature

LeafLog is a web application designed to serve as a one-stop solution for plant care, information, and personal gardening documentation. It combines user-friendly design with extensive plant data to cater to various user needs.

Hosting Strategy

The application will be cloud-hosted to ensure scalability, reliability, and availability. This approach allows for seamless performance enhancements and the ability to support a growing user base without compromising on user experience.

User Base

The platform targets a wide range of users, from beginners seeking basic plant care advice to seasoned experts looking for a comprehensive resource for advanced gardening techniques.

Technology Stack:

Front-End

We will be using React.js for developing the frontend of our solution, specifically utilizing the Next.JS framework. This is because React.js is a powerful Javascript tool that enhances the user experience, promotes code reusability and provides a scalable development process.

Back-End

For the backend we will be going with Node.js and Express.js for server side programming along with MongoDB for NoSQL database management. This technology stack is often represented as MERN Stack where we only have to learn one language i.e. javascript to program a whole full stack web app.

API

LeafLog will be utilizing the Prenual API, which is a custom-built RESTful API that provides access to a wealth of plant-based information that our users will need access to, such as species, care guides, growth stages, images and much more for varieties of tropical houseplants, sustainable outdoor plants, non-poisonous edible fruits/berries and medical herbs.

Testing

For testing, we came across a few tools and libraries, but "JEST" is something that is of our interest as the project is souly built in Javascript so we are planning to test our solution in JEST. Apart from this we will also be using POSTMAN for API testing.

Solution Design:

High-Level Context Diagram

This diagram should illustrate the overall system and its interaction with external entities.

React.js Frontend:

• Represents the user interface where users interact with the application.
• Sends requests to the Node.js backend for plant information, user data, and other services.

Node.js/Express.js Backend:

• Handles requests from the frontend.
• Interacts with the Perenual API to retrieve plant information.
• Manages data flow to and from the MongoDB database.

Perenual API:

• External service integrated into the backend.
• Provides detailed plant information in response to requests from the backend.

MongoDB Database:

• Stores user data, plant logs, and other relevant information.
• Interacts with the backend for data retrieval and storage.

Users:

• Interact with the React.js frontend.
• Include functionalities like account creation, plant logging, and accessing plant information.

Container Diagram

This diagram delves deeper into the system, showing the major components (containers) and how they interact.

React.js Frontend Container:

Includes components like User Authentication, Plant Logging Interface, and Plant Information Display. Communicates with the Node.js backend through API calls.

Node.js/Express.js Backend Container:

Comprises several components such as Authentication Server, Plant Information Controller, and User Data Management. Each component handles different aspects of the backend processing.

Perenual API Integration:

A specific component within the backend that deals with API requests and responses. Transforms API data into a format suitable for the frontend.

MongoDB Database Container:

Consists of different schemas and collections for users, plant logs, and other data. Interacts with the backend for CRUD (Create, Read, Update, Delete) operations.

Non-functional Requirements:

a. Quality -

• API Update Synchronization: Our team plans to prioritize API Update Synchronization, meaning that users will get the most accurate and robust plant information
• Wishlist Feature: A wishlist feature involves complex interactions and must be executed with high quality to ensure user satisfaction.
• Feedback System: Collecting user feedback can help to maintain and improve the quality of the application.

b. Availability

• Minimal Downtime: By carefully planning updates and integrating thorough and continuous testing throughout our app, we can ensure that users will be minimally affected by downtime that could be affected by unforeseen bugs or updates

c. Accessibility

• Inclusivity: Ensuring that the information is presented in a way that is accessible to users with disabilities, such as through screen readers or alternative text for images.

d. Testability

• User-Directed Plant Care Advice: Providing user-directed advice will likely involve complex logic that must be thoroughly testable.
• API Response Handling: Handling different types of API responses requires that the system be designed for easy testability to ensure all cases are covered.

e. Usability

• User Profile Customization: Allowing users to customize their profiles is a direct enhancement of usability.

f. Performance

• Advanced Plant Search Filters: Advanced filtering requires the system to quickly process and return filtered results, demanding high performance.

Assumptions:

User Authentication:

The system assumes the presence of a user authentication mechanism for secure access to the application's features and data.

Plant Database:

The plant database is assumed to contain a comprehensive collection of plant-related information, including plant care instructions, species details, and other relevant data.

External Plant Database API:

It is assumed that the external Plant database API provides access to a vast repository of plant-related data, which can be utilized by the application for various purposes such as information retrieval and updates.

Scalability:

The server infrastructure is assumed to be designed with scalability in mind, allowing the application to handle increasing loads and user demands effectively.

Security Measures:

The application is assumed to implement various security measures, including encryption, data validation, and access controls, to safeguard user data and ensure the integrity of the system.

Cross-Platform Compatibility:

The use of React.js for frontend development suggests that the application is designed to be cross-platform compatible, allowing users to access it from different devices and platforms seamlessly.

Continuous Development:

The solution design indicates an iterative development approach, with the possibility of ongoing updates and enhancements to the application's features and functionality.

Developer Familiarity:

The development team is assumed to have familiarity with the chosen technology stack, including React.js, MongoDB, Jest enabling efficient development and testing of the solution.

These assumptions provide a foundational understanding of the expected functionality, design principles, and development environment of the LeafLog application.