Rentra
Rentra is a software project focused on the operational complexity of rental housing. It models the relationships between people, organisations, property portfolios, buildings, units, and tenancies, including cases where a tenant uses the platform independently of their landlord.
The system has a Flutter mobile client and a modular NestJS backend backed by PostgreSQL. The backend contains domain modules for authentication, users, organisations, properties, tenants, payments, maintenance, and related workflows. The mobile application currently covers selected onboarding and tenant-facing experiences; the broader rental operations product remains under development.
- Product Engineering & Software Systems
- Flutter · Dart · NestJS 11 · TypeScript · TypeORM · PostgreSQL · Supabase · Africa's Talking · Resend
- Flutter mobile app
Screens, local session, calls the API
- NestJS service
Auth, role guards, business rules, validation
- PostgreSQL · Supabase
System of record, accessed via TypeORM
- Portfolio
- Building
- Unit
- Tenancy
The question
Rental operations involve several parties with different responsibilities. Landlords manage properties, caretakers handle delegated operational tasks, and tenants occupy units and interact with the people responsible for them. These relationships are often coordinated through fragmented records and informal communication.
The engineering challenge is to represent these relationships in a coherent system: how properties and units relate to organisations, how a tenancy connects a person to a unit, how permissions should follow those relationships, and how tenants can use the platform when their landlord is not registered.
Technical approach
Rentra uses a Flutter mobile client and a single NestJS backend. The backend is organised into domain modules and owns the API, authentication, business logic, and persistence. PostgreSQL is hosted through Supabase and accessed through TypeORM. SMS and email verification use Africa's Talking and Resend, respectively.
The domain model separates organisations, buildings, rooms, tenants, and tenancy-related records. In product language, these concepts represent rental portfolios, properties, units, and the people connected to them. Payments and maintenance have backend modules, but the existence of those modules should not be confused with complete end-to-end mobile workflows.
Authentication includes account registration and sign-in flows, one-time verification codes, JWT-based sessions, and passkey-related functionality. The backend also distinguishes managed tenants from independent tenants. An independent tenant can maintain a self-declared rental record without requiring their landlord to be registered on the platform.
The Flutter application contains onboarding, authentication, and tenant-facing screens. Its current service integration is limited, however, and several backend capabilities do not yet have complete mobile experiences. Authorisation and ownership scoping also require further work across the API.
Components and their status
NestJS backend architecture
Modular backend covering authentication, users, organisations, buildings, rooms, tenants, payments, maintenance, and dashboard functionality.
PostgreSQL persistence
Relational data model accessed through TypeORM, with PostgreSQL hosted on Supabase.
Registration and authentication
Account registration, sign-in, JWT sessions, and SMS/email verification flows.
Passkey workflows
Backend functionality for generating and redeeming landlord-issued passkeys.
Tenant onboarding and mobile experience
Flutter onboarding, verification, role selection, and selected tenant-facing screens.
Payments and maintenance
Backend modules and records exist; complete operational workflows and mobile integration remain unfinished.
Managed and independent tenants
Separate modelling for platform-managed tenancies and self-declared rental relationships.
API authorisation and ownership scoping
Role checks exist on core routes, but protection and record-level ownership enforcement need broader coverage.
Caretaker property assignments
Property-level caretaker assignment and permission scoping.
Independent-to-managed conversion
Linking a tenant's self-declared rental to a managed tenancy when the landlord joins.
My contribution
I have worked on the system architecture and domain model: defining the boundaries between backend modules, representing organisations and rental properties, and modelling the relationships between tenants, units, and tenancies.
My work also covers the relationship between the Flutter client and the NestJS API, authentication and verification flows, and the distinction between managed and independent tenants.
A central design concern has been making the software reflect real rental arrangements rather than assuming every landlord, tenant, and property is already represented on the platform. The implementation is being developed incrementally, with unfinished API protection and mobile workflows treated as outstanding engineering work.
Engineering decisions
The backend owns business rules
The mobile client is an interface to the system, not the authority on access or business rules. Authentication and authorisation decisions belong on the server, where they can be enforced independently of the client.
Model rental relationships explicitly
A person, a property, a unit, and a tenancy are different domain concepts. Keeping them distinct makes it possible to represent ownership, occupancy, and operational responsibilities without collapsing them into one user record.
Support tenants outside managed portfolios
Not every tenant's landlord will use the platform. Independent rental records allow tenants to maintain their own rental information without inventing a managed relationship that does not exist.
Separate implementation from product scope
A backend module or data model does not automatically mean a complete user-facing workflow exists. The project tracks backend foundations, mobile integration, and unfinished capabilities separately.
Current state
Rentra has a modular NestJS backend, a PostgreSQL data model, authentication and verification functionality, and a Flutter application with selected onboarding and tenant-facing workflows. Several backend domains exist, but payments and maintenance are not complete end-to-end mobile features. API authorisation and ownership scoping also need further coverage.
- The Flutter client does not yet expose the full set of backend capabilities as complete user workflows.
- Some API routes still need consistent role protection and record-level ownership checks.
- Caretaker assignment to specific properties has not been implemented.
- Converting an independent tenant record into a managed tenancy remains planned work.
- The current backend is a modular monolith, not a microservices architecture.
Next questions
- How should ownership and tenancy relationships be enforced consistently across every API operation?
- What is the safest way to complete payments and maintenance workflows from the backend through to the mobile client?
- How should caretaker responsibilities and property-level permissions be represented in the domain model?
- How can an independent rental record be linked to a managed tenancy without losing the tenant's existing history?