Boarding House Management Platform

This project was commissioned for the boarding house business owned by the company’s owner. The goal was to replace manual operational workflows with a centralized web platform that could manage tenants, rooms, payments, and property data in a more structured and accessible way.

As a Full Stack Developer, I worked across both the frontend and backend parts of the system, contributing to features such as tenant management, room availability, booking workflows, rental payment tracking, and dashboard reporting.

Background & Problem Statement

Boarding house operations are often handled through scattered spreadsheets, messaging apps, and manual record keeping. For a business that manages multiple units, this makes it difficult to track occupancy, monitor payments, and maintain a consistent view of operations.

The platform was built to address these operational challenges by providing a single system for:

• Managing multiple properties and room inventories
• Tracking tenant data and rental status
• Supporting booking and payment workflows
• Presenting business information through a centralized dashboard

Architecture & Technical Decisions

The application was built with Next.js App Router as the foundation for the frontend. This allowed server-side rendering, client-side interactions, and data fetching patterns to be handled within a single codebase while keeping the application maintainable.

The architecture separates pages that require frequent data updates from interactive UI flows. For example, dashboard pages can fetch data on the server, while booking forms and property filters can still run as client-side interactions when needed.

Server Actions were used for mutations such as updating tenant records, submitting booking requests, and handling operational changes. This approach keeps the data flow straightforward and reduces the need for separate API route boilerplate for every action.

/app
  /dashboard        → Server-rendered admin pages
    /properties     → Property management views
    /tenants        → Tenant records and status
  /search           → Property discovery and filtering
  /booking/[id]     → Booking flow and submission
/api
  /webhooks         → External payment callbacks

Data Management with Prisma & PostgreSQL

The database schema was designed around the core business entities: properties, rooms, tenants, bookings, and payments. Prisma ORM provides type-safe access to PostgreSQL, helping maintain consistency across the application.

One important consideration was dashboard performance. Property owners need immediate visibility into room availability, occupancy rates, and outstanding payments. To support this, database queries were optimized to reduce unnecessary roundtrips and efficiently aggregate operational data.

For property discovery, PostgreSQL’s built-in search capabilities were leveraged to support room and property filtering without introducing additional infrastructure.

Payment Integration

The platform integrates with an existing internal payment application through REST APIs rather than connecting directly to a third-party payment gateway.

The payment flow follows a simple process:

1. A tenant initiates a rental payment.
2. The payment application processes the transaction.
3. A webhook event is sent back to the platform.
4. The corresponding invoice and rental records are updated automatically.
5. The property owner can immediately see the updated payment status from the dashboard.

This integration reduces manual reconciliation work and helps ensure that rental and payment information remain synchronized.

Since webhook events can occasionally be delivered more than once, duplicate transaction processing is prevented by validating transaction identifiers before updating records.

Authentication & Authorization

Authentication and authorization are implemented using NextAuth, providing secure session management and access control throughout the application.

The platform supports multiple user roles, including property owners and tenants. Protected routes ensure users can only access features and data relevant to their role.

Passwords are securely hashed before storage, and application inputs are validated using Zod on both the client and server.

const bookingSchema = z.object({
  roomId: z.string().cuid(),
  checkIn: z.date().min(new Date()),
  duration: z.number().int().min(1).max(12),
  notes: z.string().max(500).optional(),
});

Using shared validation schemas helps maintain consistency between frontend forms and backend validation logic while reducing duplication.

Media Management with Cloudinary

Property and room photos are managed through Cloudinary, allowing images to be uploaded, stored, and delivered efficiently.

Direct uploads are secured using signed upload presets so sensitive credentials never reach the client. Cloudinary transformations are also used to generate optimized image formats and thumbnails automatically, improving page performance while reducing server-side processing requirements.

Current Development Status

The platform is currently under active development and continues to evolve alongside business requirements.

Core property, room, tenant, and booking management workflows have been implemented, while additional operational and reporting features are being developed incrementally based on real-world usage and stakeholder feedback.

This iterative approach allows new functionality to be introduced without disrupting existing workflows while ensuring the platform remains aligned with the needs of the business.

Key Takeaways

This project has provided valuable experience in building software for a real operational environment rather than a purely technical exercise.

Working closely with business requirements highlighted the importance of designing systems around actual workflows and user needs. Many technical decisions from data modeling and role management to booking and payment processes were influenced by how the boarding house business operates on a daily basis.

The project also reinforced the value of maintainable architecture, clear domain modeling, and iterative delivery when developing internal business applications. As the platform continues to grow, these foundations make it easier to introduce new features while keeping the system reliable and manageable.