Building a Rental App as a Test Project
In my previous blogs, I wrote about operations development and employee engagement. Both were major parts of the company that needed attention after I started taking over more responsibility.
Operations were the first major challenge. Most of the work was manual, dependent on books, memory, phone calls, and scattered communication. Slowly, I started moving the company into a more structured system by using digital logs, improving billing, tracking POD, handling payment logs, and connecting some parts of communication through automation. This helped reduce manual errors and made the daily work more trackable.
Employee engagement was another major learning curve. I had to understand how to communicate with employees, train them, handle language barriers, and also learn from hiring mistakes. Over time, I understood that systems alone are not enough. People need to understand those systems, and the systems themselves need to be simple enough for the team to actually use.
Now, after one year of changing a major part of operations and learning how people work within those systems, I feel I can start thinking about the next stage.
The next stage is not immediately about building something very large. Before building an app for the logistics company, I first want to understand how app building works in a practical way. I do not want to directly start with a complex business app without learning the process properly. So, I decided to take up a smaller internal project: a rental property management app.
This rental app is mainly for internal family use, but for me it is also a test project to learn Flutter and understand app development more clearly. The idea is to build a simple app where property owners can log in, add rental properties, add tenants, assign tenants to properties, track rent payments, update maintenance issues, upload files, and get reminders.
The app will be built using Flutter because I want to learn cross-platform development. For backend storage, I am planning to use Firebase, as it can help manage users, data, documents, and updates. Since this is a small internal app, it does not need to begin with too many users. A few user logins should be enough for the first version.
The purpose of the app is simple: reduce manual tracking.
Rental management can become scattered when details are stored in notebooks, messages, memory, or separate files. The app should bring the basic information into one place. It should answer simple questions quickly: which properties are active, who is staying where, what rent is pending, what has been paid, what maintenance issue needs attention, and whether any documents or updates are required.
The first step was to understand the appβs purpose and target users. The target users are property owners who need a simple way to manage rental details. Since this is not a public app, the design does not need to solve every rental problem in the market. It only needs to solve the actual problems of the users who will use it.
After that, I started working on the Information Architecture.
At a beginner level, I understood IA as the process of deciding what information exists inside the app and where it belongs. For this rental app, the main sections are Properties, Tenants, Payments, Documents, Maintenance, and Reminders.
Properties will store details such as property type, flat or unit details, area, photos, amenities, documents, tax-related files, and other property information. Tenants will store details such as contact information, ID proof, alternate contacts, work proof, assigned property, rent due date, and rental agreement. Payments will track rent status, pending amounts, paid amounts, file uploads, and payment updates. Maintenance will track repairs, contacts, amounts, and who the payment is payable to.
The important part was understanding that the app is not just a list of properties or tenants. The real value comes when these records are connected. A property should show which tenant is assigned to it. A tenant should show which property they are staying in. Rent should be connected to both the property and the tenant. Documents and reminders should support this structure.
Once the basic structure was clear, I moved to user flow.
The user flow starts with a simple login or signup process using a mobile number, name, and a family sharing code. Since this is an internal app, access should be limited and controlled. After login, the user reaches the home page.
The home page should act like a dashboard or heads-up display. It should show the current month, total rent, pending rent, and a list of tenants or properties that need attention. From the home page, the user should be able to check payment status, update rent, upload payment proof, and move into property or tenant details.
The bottom navigation can keep the app simple, with sections such as Home, Properties, Tenants, and User Account. The Properties section will allow users to add a new property, fill in details, view the property list, select a property, check documents, view rent amount, track maintenance, and see tenant history. The Tenants section will allow users to add tenants, fill in details, assign them to properties, upload ID proof, add alternate contact details, set rent due dates, and generate or view rental agreements.
After this, I started early low-fidelity wireframing.
The wireframes were mostly focused on the home page because that is where the user should get the most important overview. I explored different layouts for showing total rent, pending rent, month filters, pending lists, tenant tables, status indicators, and bottom navigation. At this stage, the goal was not to make the design look good. The goal was to understand where information should sit and what the user should see first.
From the wireframe brainstorming, the home page became clearer. It should first show the total situation, then what needs attention, then the list of tenants or payments, and then give navigation options. This makes the app useful from the first screen itself.
This project is still in the early stage. I have only started with purpose, target users, Information Architecture, user flow, and early wireframes. But even this process has helped me understand app development better than just watching tutorials or jumping directly into coding.
For me, this rental app is not just about managing rental properties. It is a learning project. It is a way to understand how to think before building. What is the purpose? Who is the user? What information is needed? How does the user move through the app? What should be shown first? What should be stored? What can wait for later?
These are the same questions I will eventually need to ask before building any larger app for the logistics business.
In the past year, most of my work was about fixing operations and understanding people. Now I am slowly moving into building better tools. This rental app is the starting point for that next stage.













