Real Estate Deal Pipeline & Lead Acquisition Engine with WhatsApp Chatbot

# Build a Complete Property Listings Portal with Kanban Deal Pipeline & Automatic Lead Qualification

## ROLE

You are a senior full-stack software architect, Django developer, UI/UX designer, database engineer, and QA engineer.

Build a **production-quality, fully functional Property Listings & Real Estate CRM platform** based on the requirements below.

This must be a **real working application**, not a static HTML mockup or a collection of placeholder pages.

---

# 1. CORE OBJECTIVE

Create a modern real estate platform that combines:

1. Public property listings portal
2. Property search and advanced filtering
3. Property detail pages
4. Buyer/renter registration and accounts
5. Seller/landlord property submission
6. Real estate agent accounts
7. Lead capture
8. Automatic AI-assisted lead qualification
9. Lead scoring
10. Lead management
11. Kanban deal/sales pipeline
12. Drag-and-drop pipeline management
13. Follow-ups and reminders
14. Messages and notifications
15. Property enquiry management
16. Agent/property assignment
17. Dashboard analytics
18. Reports
19. Django Admin management
20. Fully responsive mobile/tablet/desktop UI

The overall product should feel like a combination of:

* Property marketplace
* Real estate CRM
* Lead-generation system
* Sales pipeline
* Agent management dashboard

---

# 2. TECHNOLOGY REQUIREMENT

## Backend

Use:

* Python
* Django
* Django ORM
* Django Templates
* Django Forms
* Django authentication
* Django Admin
* PostgreSQL-ready architecture

### IMPORTANT

The primary framework **MUST be Django**.

Do not replace Django with:

* Laravel
* Node.js backend
* Express
* PHP
* Firebase as the primary backend
* Supabase as the primary backend

You may use JavaScript libraries on the frontend where appropriate.

---

# 3. FRONTEND

Use a modern responsive frontend.

Recommended:

* HTML5
* CSS3
* JavaScript
* Bootstrap 5 or a similarly robust responsive framework
* Bootstrap Icons / Font Awesome
* AJAX/fetch where useful
* Chart.js for analytics
* SortableJS or equivalent for Kanban drag-and-drop

The interface should look **premium, modern, clean, professional and highly usable**.

Avoid an outdated generic Bootstrap appearance.

---

# 4. DESIGN DIRECTION

Use the supplied reference image as the visual/design direction.

The application should use a:

* Professional real-estate aesthetic
* Clean white surfaces
* Charcoal/dark navigation
* Emerald/bright green primary accent
* Rounded cards
* Subtle shadows
* Spacious layouts
* Strong typography
* Clear visual hierarchy
* Modern dashboard components
* Responsive grids
* Professional property photography
* High-quality icons

### Suggested primary palette

```text
Emerald Green: #22C55E
Dark Charcoal: #1C2022
White: #FFFFFF
Light Background: #F5F7F8
Border: #E5E7EB
Muted Text: #6B7280
Success: #16A34A
Warning: #F59E0B
Danger: #DC2626
```

Do not overuse green.

Use green primarily for:

* Primary buttons
* Active navigation
* Status indicators
* Important metrics
* CTA elements
* Positive lead qualification indicators

---

# 5. APPLICATION STRUCTURE

Organize the Django project cleanly.

Suggested apps:

```text
accounts/
properties/
leads/
pipeline/
messages/
notifications/
dashboard/
analytics/
core/
```

You may adjust the architecture if there is a better Django structure, but maintain clear separation of responsibilities.

Use reusable:

* Base templates
* Components
* Template partials
* Forms
* Model mixins
* Utility functions
* Services
* Querysets/managers

Avoid putting excessive business logic inside views.

---

# 6. USER ROLES

Implement role-based access control.

Supported users:

### 1. Administrator

Can manage everything.

### 2. Real Estate Agent

Can:

* Manage assigned properties
* Manage leads
* Manage deals
* Contact prospects
* Update pipeline stages
* Add notes
* Schedule follow-ups
* View assigned analytics

### 3. Property Owner / Seller

Can:

* Create property listings
* Edit their properties
* View enquiries
* View property performance
* Receive lead notifications

### 4. Buyer

Can:

* Browse properties
* Search/filter
* Save favourites
* Submit enquiries
* Request viewing
* Contact agents
* Track enquiries

### 5. Tenant

Can:

* Search rental properties
* Save properties
* Send enquiries
* Request viewing
* Communicate with agents

---

# 7. AUTHENTICATION

Implement:

* Registration
* Login
* Logout
* Password reset
* Password change
* Profile management
* Role selection where appropriate
* Email verification architecture
* Account activation/deactivation

Do not allow users to arbitrarily escalate themselves to administrator.

Admin/agent privileges must be controlled securely.

---

# 8. PROPERTY MODEL

Create a comprehensive property model.

Include fields such as:

```text
title
slug
description
property_type
listing_type
status
price
currency
location
address
city
county
country
latitude
longitude
bedrooms
bathrooms
parking_spaces
property_size
land_size
year_built
furnished
featured
verified
owner
agent
created_at
updated_at
```

### Property Types

Support:

* Apartment
* House
* Villa
* Townhouse
* Bungalow
* Maisonette
* Office
* Shop
* Warehouse
* Commercial Building
* Land
* Farm
* Hotel
* Industrial Property
* Other

### Listing Types

Support:

* For Sale
* For Rent
* For Lease
* For Investment

### Property Status

Support:

* Draft
* Pending Review
* Published
* Under Offer
* Sold
* Rented
* Archived

---

# 9. PROPERTY MEDIA

Create a separate property image/media system.

A property should support:

* Multiple images
* Main/featured image
* Image ordering
* Image captions
* Image deletion
* Gallery display

Allow future support for:

* Video
* Virtual tour
* Floor plans
* Documents

Optimize images where possible.

Use appropriate validation for uploaded files.

---

# 10. PUBLIC PROPERTY PORTAL

Create a beautiful public-facing property marketplace.

Main navigation:

```text
Home
Properties
Buy
Rent
Sell
Agents
About
Contact
Login
Register
```

The homepage should include:

### Hero Section

Large real-estate visual.

Headline:

> Find Your Dream Property

Supporting text:

> Buy, Rent or Invest in the right property with confidence.

Include a prominent property search component.

Search fields:

```text
Location
Property Type
Listing Type
Min Price
Max Price
Bedrooms
```

CTA:

```text
Search Properties
```

---

# 11. PROPERTY LISTINGS PAGE

Create:

```text
/properties/
```

Include:

* Search
* Filters
* Sort
* Pagination
* Property cards
* Map-ready architecture
* Saved/favourite functionality

Property cards should display:

* Image
* For Sale / For Rent badge
* Featured badge
* Property title
* Location
* Price
* Bedrooms
* Bathrooms
* Size
* Agent
* Favourite button
* View Details button

Example:

```text
Modern 4 Bedroom House

Westlands, Nairobi

KES 28,000,000

4 Beds   4 Baths   300 m²

[View Details]
```

---

# 12. ADVANCED PROPERTY SEARCH

Implement real database filtering.

Filters should include:

* Keyword
* Location
* Property type
* Listing type
* Minimum price
* Maximum price
* Bedrooms
* Bathrooms
* Furnished
* Parking
* Verified
* Featured

Implement sorting:

```text
Newest
Price: Low to High
Price: High to Low
Most Popular
```

Do not fake filtering with JavaScript.

Filters must actually query the Django database.

---

# 13. PROPERTY DETAIL PAGE

Create a premium property detail page.

Include:

* Large image gallery
* Property title
* Location
* Price
* Property details
* Description
* Features
* Amenities
* Location section
* Agent profile
* Contact agent
* Request viewing
* Send enquiry
* Save property
* Share property

CTA buttons:

```text
Contact Agent
Request Viewing
Send Enquiry
```

---

# 14. PROPERTY FEATURES / AMENITIES

Create a flexible amenity system.

Examples:

* Parking
* Swimming Pool
* Garden
* Security
* CCTV
* Balcony
* Borehole
* Backup Generator
* Gym
* Internet
* Air Conditioning
* Furnished
* Servant Quarters
* Gated Community

Do not hardcode every amenity into the Property model.

Use a related Amenity model or many-to-many relationship.

---

# 15. PROPERTY ENQUIRIES

When a visitor clicks:

```text
Contact Agent
```

or

```text
Send Enquiry
```

create a lead/enquiry.

Capture:

```text
Name
Email
Phone
Property
Message
Preferred contact method
Budget
Purpose
Preferred location
Preferred property type
Timeline
```

Store the enquiry in the database.

---

# 16. LEAD MANAGEMENT

Create a complete Lead model.

Suggested fields:

```text
first_name
last_name
email
phone
source
status
lead_score
qualification_status
budget_min
budget_max
preferred_location
preferred_property_type
listing_type
bedrooms
purchase_or_rental_purpose
timeline
assigned_agent
interested_property
notes
created_at
updated_at
last_contacted
next_follow_up
```

Lead sources:

```text
Website
Property Enquiry
WhatsApp
Phone
Email
Facebook
Instagram
Google
Referral
Manual Entry
Other
```

---

# 17. AUTOMATIC LEAD QUALIFICATION

Implement an automatic lead qualification engine.

The system should evaluate incoming leads based on configurable criteria.

Example factors:

### Budget Match

Does the lead's budget match available properties?

### Property Interest

Is the lead clearly interested in a property?

### Location Preference

Does their desired location match available inventory?

### Timeline

How soon do they intend to buy/rent?

### Engagement

Have they:

* Viewed properties?
* Submitted multiple enquiries?
* Requested a viewing?
* Replied to messages?

### Completeness

How much useful information has the lead provided?

---

# 18. LEAD SCORING

Create a scoring system from:

```text
0–100
```

Example:

```text
Budget Match       +25
Property Interest  +20
Location Match     +15
Strong Timeline    +15
Viewing Requested  +15
High Engagement    +10
```

Make the scoring rules configurable rather than permanently hardcoded where practical.

Lead categories:

```text
Hot
Warm
Cold
```

Qualification status:

```text
New
Unqualified
Qualified
Highly Qualified
Converted
Lost
```

Example UI:

```text
HIGH PRIORITY LEAD

Score: 92/100

Budget: KES 20M – 30M
Interested in: 4 Bedroom House
Location: Karen
Timeline: Within 30 days

✓ Budget Match
✓ Property Match
✓ Location Match
✓ Strong Timeline
```

---

# 19. AI-ASSISTED QUALIFICATION ARCHITECTURE

Build the application so an AI provider can be integrated cleanly.

Create a service architecture such as:

```text
leads/services/qualification.py
leads/services/ai_qualification.py
```

The application must still work if no external AI API is configured.

Therefore implement:

### Fallback rule-based qualification

PLUS an optional:

### AI qualification service

The AI layer can analyze:

* Lead messages
* Requirements
* Budget
* Intent
* Property preferences
* Urgency
* Engagement

Return structured data such as:

```json
{
  "score": 87,
  "qualification": "highly_qualified",
  "intent": "buy",
  "urgency": "high",
  "budget_match": true,
  "property_match": true,
  "location_match": true,
  "summary": "Lead is actively looking for a property within budget."
}
```

Never allow AI output to bypass application permissions or security.

---

# 20. KANBAN DEAL PIPELINE

This is one of the most important features.

Create a visual Kanban pipeline.

Columns:

```text
New Leads
Contacted
Qualified
Proposal
Closed
```

You may also support:

```text
Viewing Scheduled
Negotiation
Won
Lost
```

Each lead/deal appears as a draggable card.

---

# 21. KANBAN CARD

Each card should display:

```text
Sarah Wanjiku

Apartment

KES 8,500,000

Score: 91

Westlands

2 hours ago
```

Include:

* Lead name
* Property
* Deal value
* Lead score
* Location
* Agent
* Timestamp
* Priority indicator

---

# 22. DRAG AND DROP

Implement real drag-and-drop.

When a user moves a card:

```text
New Leads → Contacted
```

the system must update the database.

Do not merely change the UI.

Use AJAX/fetch to persist the new stage.

Provide visual feedback during dragging.

---

# 23. DEAL MODEL

Create a Deal model.

Suggested fields:

```text
lead
property
agent
stage
value
probability
expected_close_date
status
notes
created_at
updated_at
```

Calculate:

```text
Weighted Pipeline Value
```

using:

```text
deal value × probability
```

---

# 24. DEAL PIPELINE DASHBOARD

Display:

```text
New Leads       18
Contacted       12
Qualified        9
Proposal         6
Closed           4
```

Also show:

```text
Total Pipeline Value
Qualified Lead Value
Closed Deal Value
Conversion Rate
Average Deal Size
```

---

# 25. MAIN ADMIN/AGENT DASHBOARD

Create a dashboard visually similar to the supplied reference image.

Sidebar:

```text
Dashboard
Properties
Leads
Deals Pipeline
Messages
Calendar
Reports
Settings
```

Top bar:

```text
Search
Notifications
User Profile
```

---

# 26. DASHBOARD KPI CARDS

Create cards for:

### Total Properties

Example:

```text
48
+12% this month
```

### Total Leads

```text
126
+28% this month
```

### Qualified Leads

```text
87
69% conversion rate
```

### Closed Deals

```text
24
+33% this month
```

Do not hardcode these values.

Calculate them from the database.

---

# 27. RECENT PROPERTIES

Dashboard section showing recent property listings.

Each property card:

```text
Image
Status
Property Name
Location
Price
Bedrooms
Bathrooms
Size
```

Add:

```text
View Details
```

and:

```text
View All
```

---

# 28. LEAD DASHBOARD

Create a lead management page.

Include:

* Lead table
* Search
* Filters
* Score
* Status
* Assigned agent
* Property
* Source
* Created date
* Next follow-up

Example:

| Lead          | Property  | Score | Status    | Agent | Source   |
| ------------- | --------- | ----: | --------- | ----- | -------- |
| Sarah Wanjiku | Apartment |    92 | Qualified | Agent | Website  |
| David Ochieng | House     |    78 | Contacted | Agent | Facebook |

Use colored status badges.

---

# 29. LEAD DETAIL PAGE

When opening a lead, show:

### Contact information

```text
Name
Phone
Email
Location
```

### Qualification

```text
Lead Score
Qualification Status
Intent
Urgency
```

### Requirements

```text
Budget
Location
Property Type
Bedrooms
Timeline
```

### Activity timeline

Example:

```text
Today, 10:45 AM
Lead submitted enquiry

Today, 11:15 AM
Agent contacted lead

Today, 12:00 PM
Viewing requested

Today, 12:30 PM
Lead qualified
```

---

# 30. LEAD NOTES

Allow agents to add notes.

Example:

```text
Client prefers gated communities and is available
for viewing this weekend.
```

Store notes with:

* Author
* Timestamp
* Lead

---

# 31. FOLLOW-UP SYSTEM

Create follow-up functionality.

Agents should be able to set:

```text
Follow-up date
Follow-up time
Reminder
Notes
```

Dashboard should show:

```text
Today's Follow-ups
Upcoming Follow-ups
Overdue Follow-ups
```

---

# 32. NOTIFICATIONS

Create an internal notification system.

Notify agents when:

* New lead arrives
* Lead becomes qualified
* Viewing is requested
* Lead is reassigned
* Deal stage changes
* Follow-up is due
* Property enquiry is received

Notification icon should display unread count.

---

# 33. MESSAGES

Create a messages interface.

Sidebar navigation:

```text
Messages
```

Support conversations between:

* Agent ↔ Lead
* Agent ↔ Property Owner

Build the architecture so real-time messaging can be added later.

For the first implementation, standard Django/AJAX messaging is acceptable.

---

# 34. CALENDAR

Create a calendar/follow-up interface.

Events may include:

```text
Property Viewing
Lead Follow-up
Meeting
Call
Deal Closing
```

Allow agents to create and manage events.

Use a professional calendar UI.

---

# 35. AGENT MANAGEMENT

Create agent profiles.

Agent profile should show:

```text
Profile Photo
Name
Phone
Email
Bio
Specialization
Properties
Active Leads
Closed Deals
```

Public agent profile:

```text
/agents/<slug>/
```

Display their properties.

---

# 36. FAVORITES

Registered users should be able to save properties.

Create:

```text
FavoriteProperty
```

Features:

* Add favourite
* Remove favourite
* Favourite count
* My Favourites page

Use AJAX for quick add/remove.

---

# 37. PROPERTY VIEWING REQUESTS

Create a viewing request model.

Fields:

```text
lead
property
preferred_date
preferred_time
message
status
assigned_agent
created_at
```

Statuses:

```text
Pending
Confirmed
Completed
Cancelled
```

Notify the assigned agent.

---

# 38. PROPERTY SUBMISSION

Property owners/agents should be able to submit properties.

Form should include:

```text
Title
Description
Property Type
Listing Type
Price
Location
Address
Bedrooms
Bathrooms
Size
Amenities
Images
```

New properties should initially be:

```text
Pending Review
```

unless the account has permission to publish directly.

---

# 39. DJANGO ADMIN

Build a powerful Django Admin interface.

Register and customize:

* Users
* Profiles
* Properties
* Property Images
* Amenities
* Leads
* Deals
* Pipeline Stages
* Notes
* Viewing Requests
* Messages
* Notifications
* Follow-ups
* Favorites

Add:

* Search
* Filters
* Ordering
* Useful list displays
* Inline editing where appropriate

Admin should be practical for a real business.

---

# 40. PIPELINE STAGES SHOULD BE CONFIGURABLE

Do not permanently hardcode pipeline stages.

Create a:

```text
PipelineStage
```

model.

Example default stages:

```text
New Leads
Contacted
Qualified
Proposal
Closed
```

Admin should be able to:

* Add stages
* Rename stages
* Change ordering
* Activate/deactivate stages
* Set colors
* Set probability

---

# 41. ANALYTICS

Create a Reports/Analytics section.

Include:

### Property Analytics

* Total properties
* Published properties
* Sold properties
* Rented properties
* Most viewed properties
* Most enquired properties

### Lead Analytics

* Total leads
* Qualified leads
* Lead sources
* Lead conversion
* Average lead score

### Sales Analytics

* Pipeline value
* Closed deals
* Revenue/value
* Conversion rate
* Agent performance

Use Chart.js.

Charts:

* Leads over time
* Leads by source
* Deals by stage
* Property listings by category
* Closed deals over time

---

# 42. SEARCH BAR

The dashboard search bar should support searching across relevant records.

Example:

```text
Search properties, leads, clients...
```

Return categorized results such as:

```text
Properties
Leads
Agents
```

---

# 43. RESPONSIVE DESIGN

This is mandatory.

The platform must work properly on:

* Desktop
* Laptop
* Tablet
* Mobile

### Mobile dashboard

Convert sidebar into:

* Offcanvas navigation
* Hamburger menu

Kanban should remain usable on mobile through:

* Horizontal scrolling
* Touch-friendly cards
* Responsive columns

Property cards should adapt from:

```text
4 columns
→
3 columns
→
2 columns
→
1 column
```

---

# 44. MOBILE PROPERTY EXPERIENCE

The mobile property page should prioritize:

1. Property image
2. Property title
3. Price
4. Location
5. Key property details
6. CTA buttons

Make:

```text
Contact Agent
Request Viewing
```

easy to access.

---

# 45. SECURITY

Implement proper Django security.

At minimum:

* CSRF protection
* Authentication
* Authorization
* Role permissions
* Object-level access checks
* Secure file upload validation
* XSS protection
* SQL injection protection through ORM
* Secure password handling
* Login protection
* Environment variables for secrets
* DEBUG configurable through environment
* ALLOWED_HOSTS configurable
* Secure production settings

Do not expose private lead information to unauthorized users.

Agents should only see leads they are authorized to access.

---

# 46. DATABASE DESIGN

Use normalized relational models.

Avoid storing repeated data unnecessarily.

Use:

```text
ForeignKey
OneToOneField
ManyToManyField
```

appropriately.

Add database indexes to frequently searched fields such as:

```text
property status
listing type
property type
city
price
lead score
lead status
pipeline stage
created_at
```

Use slugs for public URLs.

---

# 47. PERFORMANCE

Avoid obvious N+1 queries.

Use:

```python
select_related()
prefetch_related()
```

where appropriate.

Paginate large datasets.

Optimize dashboard queries.

Do not load thousands of records unnecessarily.

---

# 48. EMPTY STATES

Every major page must have a professional empty state.

Examples:

```text
No properties found.

Try changing your filters or search criteria.
```

```text
No leads yet.

New enquiries will appear here automatically.
```

Do not leave blank screens.

---

# 49. ERROR HANDLING

Create friendly error pages:

```text
404
403
500
```

Use the application's visual branding.

Do not expose Django debug information in production.

---

# 50. SAMPLE DATA

Create realistic seed/demo data so the application looks populated immediately after setup.

Include approximately:

### Properties

At least 12 realistic properties.

Examples:

```text
Modern 4 Bedroom House
Westlands, Nairobi
KES 28,000,000

Modern 2 Bedroom Apartment
Kilimani, Nairobi
KES 12,500,000

3 Bedroom Bungalow
Ruiru, Kiambu
KES 45,000/month
```

### Leads

At least 15 demo leads.

### Deals

At least 10 deals distributed across pipeline stages.

### Agents

At least 4 agents.

### Amenities

At least 15 amenities.

Use fictional/demo names and data.

Clearly structure seed data so it can be removed or replaced.

---

# 51. DEMO DASHBOARD DATA

The visual dashboard should be capable of producing metrics similar to:

```text
Total Properties: 48
Total Leads: 126
Qualified Leads: 87
Closed Deals: 24
```

However, these numbers must ultimately be generated from actual database records.

Do not permanently hardcode dashboard statistics.

---

# 52. PROPERTY CARD VISUAL DESIGN

Use premium cards.

Example structure:

```text
┌─────────────────────────────┐
│                             │
│       PROPERTY IMAGE        │
│                             │
│  FOR SALE       ♡           │
├─────────────────────────────┤
│ Modern 4 Bedroom House      │
│ 📍 Westlands, Nairobi       │
│                             │
│ KES 28,000,000              │
│                             │
│ 🛏 4   🛁 4   📐 300 m²     │
│                             │
│ [ View Details ]            │
└─────────────────────────────┘
```

---

# 53. KANBAN VISUAL DESIGN

Create visually distinct columns.

Example:

```text
NEW LEADS
──────────────
18 Leads

┌──────────────┐
│ Sarah        │
│ Apartment    │
│ KES 8.5M     │
│ Score 92     │
└──────────────┘


CONTACTED
──────────────
12 Leads


QUALIFIED
──────────────
9 Leads


PROPOSAL
──────────────
6 Leads


CLOSED
──────────────
4 Leads
```

Cards must be draggable.

---

# 54. LEAD PRIORITY VISUALIZATION

Use visual priority indicators.

Example:

```text
🔥 High Priority
🟡 Medium Priority
⚪ Low Priority
```

Do not depend exclusively on emoji; also provide accessible badges/icons.

---

# 55. DASHBOARD LAYOUT

Desktop dashboard should generally follow this structure:

```text
┌──────────────┬────────────────────────────────────────────┐
│              │ Search                         Profile     │
│ Dashboard    ├────────────────────────────────────────────┤
│ Properties   │                                            │
│ Leads        │ KPI  KPI  KPI  KPI                         │
│ Pipeline     │                                            │
│ Messages     ├─────────────────────┬──────────────────────┤
│ Calendar     │ Recent Properties   │ Deal Pipeline        │
│ Reports      │                     │                      │
│ Settings     │                     │                      │
│              ├─────────────────────┼──────────────────────┤
│              │ Analytics           │ Lead Qualification   │
└──────────────┴─────────────────────┴──────────────────────┘
```

---

# 56. LEAD QUALIFICATION PANEL

Create a dashboard card titled:

```text
Automatic Lead Qualification
```

Supporting text:

```text
Our AI analyzes incoming leads and scores them based on:
```

Show:

```text
✓ Budget match
✓ Property interest
✓ Location preference
✓ Engagement level
✓ Timeline
✓ Instant lead scoring & routing
```

Then show an example qualified lead:

```text
HIGH PRIORITY LEAD

Score: 92/100

Budget: KES 20M – 30M
Interested in: 4 Bedroom House
Location: Karen

[View Lead]
```

The displayed information must come from actual lead data in the production implementation.

---

# 57. DASHBOARD QUICK ACTIONS

Create buttons such as:

```text
+ Add Property
+ Add Lead
+ Create Deal
+ Schedule Viewing
```

---

# 58. PROPERTY MANAGEMENT DASHBOARD

Create a property management table.

Columns:

```text
Property
Type
Location
Price
Status
Views
Enquiries
Agent
Updated
Actions
```

Actions:

```text
View
Edit
Duplicate
Archive
Delete
```

Use confirmation dialogs for destructive actions.

---

# 59. LEAD SOURCE TRACKING

Track lead sources accurately.

Dashboard chart:

```text
Website
Google
Facebook
Instagram
WhatsApp
Referral
Phone
Email
Other
```

This should allow the business to determine which acquisition channels generate leads.

---

# 60. API-READY ARCHITECTURE

Even if the first version primarily uses Django templates, structure the backend so APIs can be added later.

Keep business logic in reusable services.

Possible future API endpoints:

```text
/api/properties/
/api/leads/
/api/deals/
/api/agents/
/api/dashboard/
```

Do not make the entire application dependent on hardcoded frontend logic.

---

# 61. EMAIL ARCHITECTURE

Create an email service layer.

Support future notifications such as:

```text
New enquiry
Lead qualified
Viewing confirmation
Follow-up reminder
Deal update
Welcome email
Password reset
```

Use Django's email framework.

Development should support console/email backend configuration.

---

# 62. WHATSAPP-READY LEAD CONTACT

For every lead with a valid phone number, provide a:

```text
WhatsApp
```

action.

Generate a properly encoded WhatsApp click-to-chat URL.

Do not expose phone numbers unnecessarily in public pages.

---

# 63. SEO

Public property pages should be SEO-friendly.

Implement:

* Meaningful page titles
* Meta descriptions
* Canonical URLs where appropriate
* SEO-friendly slugs
* Semantic HTML
* Open Graph metadata
* Structured property data architecture

Create a basic:

```text
robots.txt
sitemap.xml
```

using Django where appropriate.

---

# 64. ACCESSIBILITY

Follow accessibility best practices.

Include:

* Proper labels
* Keyboard navigation
* Focus states
* Alt text
* Sufficient contrast
* ARIA attributes where appropriate
* Accessible form validation

Do not use color alone to communicate status.

---

# 65. CODE QUALITY

Follow professional Django standards.

Use:

* PEP 8
* Clear naming
* Reusable functions
* Class-based views where appropriate
* Thin views
* Service layer for business logic
* Model methods only where appropriate
* Meaningful comments
* No unnecessary duplication

Do not generate one giant Django file containing the entire application.

---

# 66. ENVIRONMENT CONFIGURATION

Create:

```text
.env.example
```

with settings such as:

```text
SECRET_KEY=
DEBUG=True
DATABASE_URL=
ALLOWED_HOSTS=
EMAIL_HOST=
EMAIL_PORT=
EMAIL_HOST_USER=
EMAIL_HOST_PASSWORD=
DEFAULT_FROM_EMAIL=
AI_API_KEY=
```

Never commit real secrets.

Create a suitable `.gitignore`.

---

# 67. REQUIREMENTS

Create a proper:

```text
requirements.txt
```

containing the required dependencies.

Keep dependencies reasonable.

---

# 68. DOCUMENTATION

Create a comprehensive:

```text
README.md
```

Include:

1. Project overview
2. Features
3. Tech stack
4. Installation
5. Virtual environment setup
6. Environment variables
7. Database setup
8. Migrations
9. Seed/demo data
10. Running development server
11. Creating superuser
12. Running tests
13. Production deployment notes
14. Static/media configuration

---

# 69. TESTING

Write meaningful Django tests.

At minimum test:

### Authentication

* Registration
* Login
* Permissions

### Properties

* Create property
* Update property
* Publish property
* Search
* Filtering

### Leads

* Lead creation
* Lead scoring
* Lead assignment
* Qualification

### Pipeline

* Deal creation
* Stage changes
* Permission checks

### Favorites

* Add favourite
* Remove favourite

### Viewing requests

* Create request
* Status changes

### Security

Verify users cannot access another agent's restricted data.

---

# 70. URL STRUCTURE

Use clean URLs.

Examples:

```text
/
 /properties/
 /properties/<slug>/
 /buy/
 /rent/
 /sell/
 /agents/
 /agents/<slug>/
 /favorites/
 /contact/
```

Dashboard:

```text
/dashboard/
/dashboard/properties/
/dashboard/leads/
/dashboard/leads/<id>/
/dashboard/pipeline/
/dashboard/messages/
/dashboard/calendar/
/dashboard/reports/
/dashboard/settings/
```

Authentication:

```text
/accounts/login/
/accounts/register/
/accounts/logout/
/accounts/password-reset/
```

---

# 71. TEMPLATE STRUCTURE

Use a clean template hierarchy.

Example:

```text
templates/
    base.html

    public/
        home.html
        properties.html
        property_detail.html
        agents.html
        agent_detail.html

    accounts/
        login.html
        register.html
        profile.html

    dashboard/
        dashboard.html
        properties.html
        leads.html
        lead_detail.html
        pipeline.html
        messages.html
        calendar.html
        reports.html
        settings.html

    components/
        property_card.html
        lead_card.html
        pipeline_card.html
        notification_dropdown.html
        pagination.html
```

Use `{% include %}` for reusable components.

---

# 72. JAVASCRIPT STRUCTURE

Do not place all JavaScript in one huge file.

Organize functionality logically.

Example:

```text
static/
    css/
        app.css
        dashboard.css
        properties.css

    js/
        app.js
        property-search.js
        favorites.js
        pipeline.js
        leads.js
        notifications.js
        dashboard.js
```

---

# 73. AJAX FEATURES

Use AJAX/fetch for:

* Favourite toggle
* Kanban stage changes
* Notifications
* Quick lead status changes
* Search suggestions
* Messaging where appropriate

Return proper JSON responses.

Handle errors gracefully.

---

# 74. LOADING STATES

AJAX operations should have loading states.

Example:

```text
Saving...
Updating...
Processing...
```

Prevent duplicate submissions.

---

# 75. FLASH MESSAGES

Use Django messages framework for actions such as:

```text
Property created successfully.
Lead assigned successfully.
Deal stage updated.
Viewing request submitted.
Property added to favourites.
```

---

# 76. DEMO LOGIN

For development/demo purposes, provide documented demo accounts.

Example:

```text
Admin:
admin@example.com

Agent:
agent@example.com

Buyer:
buyer@example.com

Owner:
owner@example.com
```

Do not hardcode insecure production credentials.

Seed them only through a development/demo command and clearly document that passwords must be changed.

---

# 77. MANAGEMENT COMMANDS

Create useful Django management commands.

Example:

```text
python manage.py seed_demo_data
```

This should populate:

* Users
* Agents
* Properties
* Leads
* Deals
* Pipeline stages
* Amenities

Make the command safe and repeatable.

---

# 78. CONFIGURABLE BUSINESS SETTINGS

Create settings that administrators can manage where practical:

```text
Currency
Lead scoring thresholds
Pipeline stages
Lead sources
Property types
Amenities
Notification preferences
Company information
```

Default currency:

```text
KES
```

---

# 79. KENYAN REAL ESTATE SUPPORT

The application should work naturally for the Kenyan market while remaining globally extensible.

Support:

```text
KES
Nairobi
Kiambu
Mombasa
Kisumu
Nakuru
Machakos
Kajiado
Other counties
```

Do not hardcode the application exclusively to Kenya.

Use configurable:

```text
Country
Currency
Location
```

---

# 80. IMAGE/REFERENCE IMPLEMENTATION

Use the supplied reference image as inspiration for the **overall visual hierarchy**, particularly:

* Dark sidebar
* White dashboard
* Emerald green accent
* KPI cards
* Property cards
* Kanban pipeline
* Lead qualification panel
* Responsive laptop/mobile property experience
* Clean professional typography
* High information density without clutter

Do not simply reproduce the image as a static screenshot.

Every visible component represented in the concept should become a functional application feature where applicable.

---

# 81. IMPORTANT: DO NOT BUILD A STATIC MOCKUP

This requirement is critical.

DO NOT:

* Hardcode fake dashboard numbers
* Hardcode property cards
* Hardcode Kanban cards
* Create fake buttons that do nothing
* Use static arrays instead of database models
* Create fake filters
* Create fake drag-and-drop
* Use screenshots as the application UI
* Leave major navigation links broken

Instead:

```text
Database → Django Models → Views/Services → Templates/AJAX → Real UI
```

Every major feature must be connected end-to-end.

---

# 82. DEVELOPMENT WORKFLOW

Follow this implementation order:

## Phase 1 — Foundation

* Create Django project
* Configure settings
* Configure static/media
* Configure database
* Create apps
* Create base templates
* Create authentication

## Phase 2 — Property Marketplace

* Property models
* Amenities
* Images
* Property CRUD
* Search
* Filters
* Property details
* Favourites

## Phase 3 — Leads

* Lead model
* Enquiry forms
* Lead dashboard
* Lead detail
* Lead scoring
* Qualification

## Phase 4 — CRM Pipeline

* Deal model
* Pipeline stages
* Kanban
* Drag/drop
* AJAX persistence

## Phase 5 — Dashboard

* KPIs
* Charts
* Recent properties
* Recent leads
* Qualification panel
* Pipeline summary

## Phase 6 — Communication

* Messages
* Notifications
* Follow-ups
* Calendar
* Viewing requests

## Phase 7 — Admin

* Django Admin
* Permissions
* Configurable settings

## Phase 8 — Testing

* Unit tests
* Integration tests
* Permission tests
* UI functionality verification

## Phase 9 — Polish

* Responsive design
* Accessibility
* SEO
* Empty states
* Error pages
* Loading states
* Performance optimization

---

# 83. BEFORE CODING

Before making major changes:

1. Inspect the existing repository.
2. Determine whether this is a new or existing Django project.
3. Inspect:

   * `manage.py`
   * settings
   * URLs
   * installed apps
   * models
   * templates
   * static files
   * requirements
   * existing database configuration
4. Reuse existing functionality where appropriate.
5. Do not unnecessarily rewrite working code.
6. Identify conflicts with the current architecture.
7. Then implement the new system incrementally.

If the project is empty, create the Django architecture from scratch.

---

# 84. DO NOT ASK FOR PERMISSION FOR EVERY SMALL STEP

You are expected to implement the application.

Make reasonable engineering decisions yourself.

Only stop and ask for clarification if a decision would fundamentally change:

* Business requirements
* Data architecture
* Security
* Payment processing
* External API usage
* Destructive modification of existing user data

Otherwise proceed.

---

# 85. ACCEPTANCE CRITERIA

The project is considered complete only when:

### Public Portal

* Homepage works
* Property search works
* Filters work
* Property detail pages work
* Registration/login work
* Favourites work
* Enquiries work
* Viewing requests work

### CRM

* Leads are created automatically from enquiries
* Lead scores are calculated
* Leads can be assigned
* Lead status can be updated
* Lead details work
* Notes work
* Follow-ups work

### Pipeline

* Deals are created
* Kanban columns load from database
* Cards load from database
* Cards can be dragged
* Stage changes persist to database
* Pipeline metrics update correctly

### Dashboard

* KPI values are database-driven
* Property cards are database-driven
* Lead data is database-driven
* Pipeline data is database-driven
* Charts use real data

### Admin

* All important models are manageable
* Permissions work
* Pipeline stages are configurable
* Property management works
* Lead management works

### Responsive

Verify the UI at:

```text
Desktop
Laptop
Tablet
Mobile
```

---

# 86. FINAL QA CHECKLIST

Before declaring the project finished, test the complete workflow:

```text
Visitor
   ↓
Views Property
   ↓
Creates Enquiry
   ↓
Lead Created
   ↓
Lead Qualification Runs
   ↓
Lead Score Generated
   ↓
Lead Assigned to Agent
   ↓
Deal Created
   ↓
Deal Appears in New Leads
   ↓
Agent Contacts Lead
   ↓
Drag Deal → Contacted
   ↓
Lead Becomes Qualified
   ↓
Drag Deal → Qualified
   ↓
Viewing Scheduled
   ↓
Proposal/Negotiation
   ↓
Deal Closed
```

Verify that the entire workflow works using real database records.

---

# 87. CODE COMPLETION REQUIREMENT

Do not stop after creating models.

Continue until the application has:

```text
Models
Migrations
Admin
Forms
Views
URLs
Templates
CSS
JavaScript
AJAX
Permissions
Seed data
Tests
Documentation
```

where required.

If you encounter an error during implementation:

1. Diagnose it.
2. Fix the root cause.
3. Run the relevant tests/checks again.
4. Continue implementation.

Do not leave known errors unresolved.

---

# 88. FINAL DELIVERABLE

At completion, provide a concise implementation report containing:

```text
1. What was built
2. Django apps created/modified
3. Database models
4. Major features
5. Authentication/roles
6. Lead qualification system
7. Kanban pipeline
8. Dashboard analytics
9. Admin functionality
10. Tests performed
11. Commands to run the project
12. Any remaining optional enhancements
```

Most importantly:

> **Build the actual working real estate platform, not merely the appearance shown in the reference image.**

The final application should feel like a **professional SaaS-grade property marketplace + real estate CRM + automated lead qualification platform**, with the reference image serving as the visual/product direction.