jamalcampbell.ai

I Renovated a Property and Couldn't Price It. So I Built PHLRenting

2026-04-19T00:00:00-05:00

Listen to this article

When Zillow tells a Philadelphia landlord their rent should be "between $1,800 and $2,600," that $800 gap is the difference between a profitable investment and a monthly loss.

I know because I put myself in those shoes. Standing in a freshly renovated property, asking myself: What is this actually worth? How do I factor in the new kitchen, ductless mini-split unit or window AC units (or a mix of the two), the parking spot on a crowded street and dedicated parking behind the structure?

National tools couldn't answer these questions. So I built one that does.

Try PHLRenting →

The Problem: Broad But Shallow

Zillow and Redfin are "broad but shallow." They have data everywhere, but they miss the ground truth nuances of specific neighborhoods. They don't know that a parking spot in Fishtown adds $150/month while one in Chestnut Hill adds nothing. They don't weight the difference between an updated versus original bathroom in a Passyunk Square rowhouse.

Their Automated Valuation Models treat entire zip codes as homogeneous. They can't see variance from one block to the next in street noise, proximity to transit, or the impact of a new restaurant anchor.

General tools give you ranges. Local tools give you pricing.

The Solution: Hyper-Local Data Empowerment

PHLRenting is built on a simple philosophy: real estate is fundamentally local.

Instead of aggregating millions of nationwide listings into a blurry average, I focused on perfecting fifteen Philadelphia zip codes. Every neighborhood has calibrated market data. Every amenity adjustment is tuned to what actually matters here.

Factor	National Giants	PHLRenting
Baseline	Aggregated MLS & Public Records	HUD Fair Market Rent (by zip code)
Market Data	Transacted data (lagging)	Rentcast API + Local Calibration
Transparency	Black box algorithms	Every adjustment visible
Utilities	Assumes included	Adjusts when tenant pays
Focus	Scaling to 50 states	Perfecting 15 Philadelphia Zip Codes

The tool asks you real questions: Does the unit have laundry? Central HVAC or window units? Or a mix of the two? Parking included? Pet friendly? These aren't hypotheticals. They're the differentiators that landlords actually negotiate on.

The Architecture: API Connected and Cache Aware

View the Full Architecture Diagram →

PHLRenting isn't a static spreadsheet. It connects to the Rentcast API for current market data by zip code and bedroom count.

Here's what happens when you calculate:

HUD Baseline: Your zip code and bedroom count pull the FY 2026 Small Area Fair Market Rent
Market Reference: Rentcast API (with 7-day caching) provides current listing context
Condition Applied: Property condition multiplies the HUD baseline
Utility Adjustment: If tenant pays utilities, the appropriate deduction applies
Amenity Premiums: Each feature adds its calibrated premium
Sweet Spot Calculation: The algorithm rounds to the nearest $25 and generates conservative/optimal/aggressive ranges

The frontend is React. The pricing algorithm is transparent. Every adjustment shows you exactly what it added or subtracted and why.

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   User Input    │────▶│    HUD FMR      │────▶│ Pricing Engine  │
│   (Property)    │     │   (Baseline)    │     │  (Adjustments)  │
└─────────────────┘     └─────────────────┘     └─────────────────┘
        │                        │                        │
        │               ┌────────┴────────┐               │
        │               │  Rentcast API   │               │
        │               │ (Market Context)│               │
        │               └─────────────────┘               │
        │                        │                        │
        │               ┌────────┴────────┐               │
        │               │  localStorage   │               │
        │               │  (7-day cache)  │               │
        │               └─────────────────┘               │
        │                                                 │
        ▼                                                 ▼
┌─────────────────────────────────────────────────────────────────┐
│                         PHLRenting UI                           │
│   • HUD FMR Base            • Utility Adjustment                │
│   • Recommended Rent        • Amenity Breakdown                 │
│   • Market Position         • Pricing Range                     │
└─────────────────────────────────────────────────────────────────┘

The Pricing Methodology: Transparent by Design

PHLRenting doesn't hide its math. Every recommendation is built from auditable inputs.

Foundation: HUD Fair Market Rent

Instead of relying solely on volatile listing data, PHLRenting starts with HUD Small Area Fair Market Rents (SAFMRs). These are the federal government's baseline rents, published annually for each zip code.

Neighborhood	Studio	2BR	3BR
Rittenhouse (19103)	$2,140	$2,810	$3,380
Fishtown (19125)	$1,770	$2,320	$2,800
Fairmount (19130)	$1,980	$2,590	$3,120
Overbrook (19131)	$1,390	$1,800	$2,160
Germantown (19144)	$1,250	$1,640	$1,980
West Mount Airy (19119)	$1,280	$1,680	$2,030

Why HUD as the baseline? These rates represent the 40th percentile of actual rents. They provide a stable foundation that varies by neighborhood and updates annually (FY 2026 data, effective October 2025). Rentcast and listing data provide market context, but HUD anchors the calculation to a defensible standard.

Condition Multipliers

Property condition applies as a multiplier to the HUD baseline:

Condition	Multiplier	Example (2BR in Fishtown)
Excellent	+10%	$2,320 → $2,552
Good	baseline	$2,320
Fair	-5%	$2,320 → $2,204
Poor	-15%	$2,320 → $1,972

Utility Adjustments

HUD Fair Market Rent assumes utilities are included. Most Philadelphia rentals are "plus utilities." PHLRenting adjusts accordingly:

Utility Arrangement	2BR Adjustment	3BR Adjustment
All utilities included	$0	$0
Tenant pays electric only	-$63	-$77
Tenant pays electric & gas	-$105	-$128
Tenant pays all utilities	-$140	-$170

This ensures landlords pricing "plus utilities" aren't accidentally overpricing against a baseline that assumes utilities are included.

Amenity Premiums

Calibrated for Philadelphia's rental market:

Feature	Premium	Notes
Central AC	+$75	Full coverage
Ductless mini-split	+$65	Modern, efficient
Mini-split + window AC allowed	+$45	Common Philly setup
Laundry in unit	+$100	Top tenant priority
Laundry in building	+$25	Shared facilities
Garage parking	+$125	Premium in dense areas
Dedicated spot	+$85	Private parking
Street parking	+$35	Permit areas
Recently renovated	+$150	Updated kitchen/bath
Pet friendly	+$50	Expands tenant pool
Private outdoor space	+$75-100	Patio/balcony/yard
Dishwasher	+$25	Expected in renovated units

Parking options are additive—a property with both garage and dedicated spot parking gets both premiums.

The Formula

Recommended Rent = HUD FMR Base (by zip + bedroom)
                 × Condition Multiplier
                 + Utility Adjustment
                 + Amenity Premiums
                 + Square Footage Adjustment
                 + Bathroom Adjustment

Every component appears in the results breakdown. No black boxes, no unexplained numbers.

Why Landlords Need Local Tools

National tools fail at the "last mile" in three specific ways:

1. Spot Market vs. Transacted Market

Zillow relies on transacted data: past leases and public records. In a fast-moving market, that's a rearview mirror showing what happened six months ago.

A hyper-local tool can capture the spot market: current asking prices and demand signals.

2. The Amenity Gap

A national algorithm sees "Renovated" as a binary checkbox. It doesn't know that in Fishtown, a chef's kitchen commands a $200 premium while a pool adds zero value. PHLRenting knows.

3. Utility Blindness

HUD Fair Market Rent includes utilities. Most Philadelphia rentals are "plus utilities." National tools don't distinguish—they compare apples to oranges.

PHLRenting asks directly: Who pays utilities? Then adjusts the baseline accordingly. A 2BR where the tenant pays all utilities gets a $140 deduction from the HUD base. This prevents landlords from accidentally overpricing against a standard that assumes utilities are included.

The result: Accurate pricing whether utilities are included or paid by the tenant.

The Technology Stack

For those who want to understand the implementation:

Frontend: React 18 with hooks for state management. CSS custom properties enable the dark accented color scheme. Responsive design works on desktop and mobile.

API Layer: Rentcast provides market data by zip code and bedroom count. The service module handles caching, validation, and graceful fallback to static data when API is unavailable.

Pricing Engine: A transparent algorithm calculates adjustments for condition, amenities, size, and market position. Every modifier is visible in the results breakdown.

Deployment: Netlify hosts the production build with automatic deployments from GitHub.

The BALANCE Philosophy

I built PHLRenting following the principles I apply to every automation project:

Boundary driven: Not trying to be the calculator for everyone. Just for Philadelphia landlords who need accuracy over coverage.
Niche: Being "small" allows precision that billion-dollar algorithms can't achieve.
Leveraged: The tool integrates into landlord workflows rather than replacing them. Export the data to your own analysis.
Enduring: Built as a long-term asset for local investors who need reliability.

This isn't about competing with Zillow or Redfin on a feature-by-feature basis. That's a losing game. It's about being the corrective lens for the last mile analysis.

See It Working

Live Demo: philly-rental-pricing.netlify.app

Supported Neighborhoods (15 zip codes): - Center City: Rittenhouse (19103), Old City (19106), Washington Square (19107) - University City: 19104 - Northwest: West Mount Airy (19119), Germantown (19144), East Mount Airy (19150) - North Philly: Brewerytown (19121) - Fishtown/NoLibs: Northern Liberties (19123), Fishtown (19125) - Fairmount: 19130 - West Philly: Overbrook (19131), Overbrook Park (19151) - South Philly: Graduate Hospital (19146), Passyunk (19148)

What you get: - HUD FMR baseline with current market reference - Transparent adjustment breakdowns for every factor - Utility toggle for "plus utilities" pricing - Conservative, optimal, and aggressive price ranges - Market position analysis (above/below baseline)

Architecture Diagram: View the full system design

The Bigger Picture

I didn't just build a calculator. I built a local data engine.

For solopreneurs and real estate investors, this is how you use niche AI orchestration to outmaneuver billion-dollar corporations. You don't need more data. You need better data, constrained to your actual market.

National tools are the weather forecast: good for broad discovery. Local tools are the soil sample: what you need before you plant a crop.

Data with Context beats Data with Volume every time.

Interested in building something similar for your market or business? I design and implement AI workflow systems for small businesses ready to scale. Tell me what you're looking to build →

Version: 2026.2 | Data: HUD FY 2026 SAFMRs | Architecture: View Diagram | Demo: Try It

Why I Built an AI Tax Assistant That Actually Cites Its Sources

2026-02-07T00:00:00-05:00

Ask ChatGPT a tax question. Go ahead. I'll wait.

Did it give you a confident answer? Good. Now try to verify it. Where did that information come from? What IRS publication? What tax year?

You can't verify it because the AI doesn't know either. It's pattern matching across the internet's collective understanding of taxes, which includes outdated blog posts, forum speculation, and content written by people who got it wrong.

This is the hallucination problem applied to something that matters: your money.

I built a different kind of system. One that only answers from authoritative sources and shows you exactly where every answer comes from.

Try the Live Demo → First load may take 30-60 seconds while the server wakes up.

The Problem With General Purpose AI and Specialized Knowledge

Large language models are trained on the internet. The internet contains a lot of tax information. Most of it is:

Outdated: Tax law changes yearly
Oversimplified: "You can deduct your home office!" (Maybe. Under specific conditions. For certain taxpayer categories.)
Contextually wrong: Advice for W-2 employees applied to 1099 contractors
Confidently stated: The AI doesn't hedge because the training data didn't hedge

When a client or business owner asks an AI about deducting medical expenses, they don't need a general overview. They need to know that medical expenses are deductible only to the extent they exceed 7.5% of adjusted gross income, as stated in IRS Publication 502.

General AI gives you summaries. Domain specific AI gives you citations.

The Solution: Retrieval Augmented Generation (RAG)

RAG is the pattern that makes AI trustworthy for specialized knowledge.

The shift: Don't ask the AI what it knows. Give it your documents and ask it to read them for you.

📄

Ingest Docs

→

🧩

Chunk & Embed

→

🔍

→

🤖

Generate

→

📎

Cite Sources

The AI can't hallucinate tax advice because it's constrained to the source material. Click any citation to verify the answer yourself.

The Architecture: Design Decisions That Matter

Building a RAG system means making choices at every layer. Here's how I thought through each one.

View the Full Architecture Diagram

The Embedding Question: How do you convert text into something a computer can search semantically? I went with OpenAI's text-embedding-3-small. It's fast, accurate, and the API means no GPU infrastructure to manage. The tradeoff is API costs at scale, but for a demo proving the pattern, operational simplicity won.

The Vector Store Decision: Once you have embeddings, where do you store and search them? Qdrant Cloud. Managed infrastructure, generous free tier, and a clean API. Could I have used Pinecone? Sure. Postgres with pgvector for a more integrated stack? Absolutely. The choice matters less than understanding that this layer is about similarity search, and any tool that does similarity search well will work.

The LLM Choice: Claude handles response generation. It receives retrieved context plus the user's question and synthesizes an answer. The prompt engineering matters here: explicit instructions to answer only from provided sources, to cite specifically, to acknowledge when the sources don't contain relevant information. This is where hallucination prevention lives.

The Frontend Reality: React with TypeScript because I wanted type safety and a component model that scales. Tailwind because life is too short for CSS debugging. Vite because fast builds make development pleasant. These choices are almost aesthetic. The important thing is that the frontend handles streaming responses so users see answers generating in real time.

The Deployment Constraint: Render hosts the demo in a Docker container. I originally tried local embedding models (SentenceTransformer) but they require nearly a gigabyte of RAM just to load. Free tier resources are limited everywhere, so I moved to hosted embeddings. This is the kind of tradeoff you discover in production, not in tutorials.

The architecture diagram shows every layer with alternatives. Not because you should swap things out, but because understanding what's swappable helps you see where the actual value lives: the RAG pattern itself.

What You See When You Use It

The interface is intentionally simple. A chat window with suggested questions to get you started.

Ask about home office deductions. Here's what happens behind the scenes:

From Question to Cited Answer

What happens in milliseconds when you ask a tax question

Embed

Your question becomes a 1536-dimension vector, capturing its semantic meaning

Qdrant finds the document chunks closest to your question in vector space

Retrieve

Top matches return with full text and metadata: source document, page, section

Ground

Claude receives your question + retrieved context with strict instructions: answer only from these sources

Stream

The response generates token by token, appearing in real time as you watch

✓

Cite

Clickable source citations appear below, each linking to the exact text used

Click any source. You see the exact text the AI used to formulate its response. No black box. Complete traceability.

The AI can still be wrong about interpretation. But you can verify the source material yourself.

The Technology Stack Explained

For those who want to understand the implementation:

Frontend: React with TypeScript, styled with Tailwind CSS, built with Vite. The chat interface handles Server Sent Events for streaming responses.

Backend: FastAPI running Python 3.11. Modular service architecture separating concerns: embeddings, vector store, LLM, document processing, chat history.

Vector Search: Qdrant Cloud stores document chunks as high dimensional vectors. When a question comes in, we embed it and find the nearest neighbors in vector space. This is semantic search, finding documents by meaning rather than keywords.

LLM: Claude handles the response generation. It receives the user's question plus the retrieved context and generates an answer grounded in those sources.

Embeddings: OpenAI's text-embedding-3-small converts text to 1536 dimensional vectors. This runs on every question and was used during document ingestion.

Persistence: Upstash Redis stores chat history, enabling conversation continuity across sessions.

Deployment: Docker container on Render. The entire application (frontend, backend, static assets) runs in a single container that scales on demand.

Why This Matters Beyond Tax Questions

The pattern here applies to any domain where:

Accuracy matters more than speed
Source attribution is required
The knowledge base is authoritative and bounded
Hallucination has real consequences

Legal documents. Medical protocols. Compliance requirements. Internal policy. Product documentation.

Anywhere you need AI to answer from your sources rather than the internet's collective imagination.

Try It Yourself

Live Demo: ai-tax-assistant-y0yz.onrender.com

Ask about home office deductions
Ask about charitable contribution limits
Ask about medical expense thresholds
Click the source citations to see the underlying text

Architecture Diagram: View the full system design

What's Next

This demo uses sample IRS content. A production system would ingest the full IRS publication library, implement document upload for custom sources, and add more sophisticated chunking strategies.

The foundation is in place. The pattern is proven.

RAG is how you make AI trustworthy for domains where being wrong isn't acceptable.

Building AI systems for your business? I design and implement workflow automations that leverage your authoritative sources. Tell me what you're looking to build

System Version: 2026.1 | Architecture: View Diagram | Demo: Try It

From Theory to Production: Building an AI Email Triage System with Human-in-the-Loop

2026-01-27T00:00:00-05:00

Listen to this article

Many people blog and speak about AI email triage in theoretical terms. Concepts, possibilities, someday-maybes. I've taken a different approach: I built a working implementation you can test right now.

This isn't a slideware presentation. It's a production-ready framework that classifies emails, generates AI draft replies, and routes everything through a human approval workflow. And I'm sharing the entire architecture so you can adapt it for your own business.

Try the Live Demo → First load may take 30-60 seconds while the server wakes up.

The Problem with Pure AI Automation

Let me be direct: the biggest barrier to AI adoption in small and medium businesses isn't the technology. It's trust.

Pure AI automation is fast, but it can lack nuance. It can "hallucinate" facts confidently. One bad automated email to an important client can burn a bridge that took years to build.

Consider these real scenarios:

The Hallucination Liability: AI confidently quotes the wrong price to a prospect
The EQ Gap: A robotic response to a frustrated customer who needed empathy
The Black Box Problem: Automation runs for weeks before you discover it's been misrouting complaints

These aren't hypothetical risks. They're why most businesses hesitate at the threshold of AI adoption.

The Solution: Human-in-the-Loop Orchestration

The answer isn't choosing between AI efficiency and human judgment. It's designing systems that leverage both.

Here's the workflow I built:

Email Arrives → AI Classifies → AI Drafts Reply → Human Reviews → Approved → Action

The AI handles the heavy lifting:

Categorizes incoming emails into 10 business categories
Assesses urgency and priority
Generates contextually appropriate draft replies
Routes everything to the right queue

The human remains the gatekeeper:

Reviews AI work in a familiar interface (Airtable)
Edits drafts when nuance is needed
Approves or rejects with one click
Maintains full visibility without being "in the weeds"

Result: You get 90% of the efficiency gains while maintaining 100% quality control.

The Architecture: Built for Change

Here's where my approach differs fundamentally from most tutorials.

I'm AI-tool agnostic. I teach and endorse orchestration pattern discovery, which means identifying workflows that are durable even as the tools evolve.

My core philosophy: Problems and workflows are stable. Tools change constantly.

This framework is modular by design. Every component can be swapped:

Layer	Current Tool	Alternatives
LLM	Claude (Anthropic)	GPT-5, Gemini, Llama, Bedrock
Approval Queue	Airtable	Notion, Google Sheets, Slack, Jira
Dashboard	Streamlit	Gradio, React, Retool
Orchestration	Python	Airflow, Prefect, n8n, Make
Storage	JSON	PostgreSQL, MongoDB, Supabase

View the Full Architecture Diagram →

The investment is in the pattern, not the specific tools. When a better LLM emerges, swap it. When your team prefers Notion over Airtable, swap it. The workflow remains intact.

Why Human-in-the-Loop Wins

Let me break down the specific pain points this architecture solves:

1. Eliminates Hallucination Risk

The AI generates its "best guess" draft based on classification and context. But it sits in a staging area for a human to give a 5-second review before anything sends.

Pain Point Solved: Zero risk of embarrassing automated responses while still saving 90% of typing time.

2. Preserves Emotional Intelligence

AI flags sentiment (e.g., "High Frustration Detected") and escalates appropriately rather than attempting a tone-deaf automated reply.

Pain Point Solved: High emotion situations receive the human empathy they require.

3. Restores Operational Visibility

Humans review a dashboard of what the AI categorized and drafted. You stay "in the loop" on what's happening without being "in the weeds" of every thread.

Pain Point Solved: The "black box" becomes a glass box.

4. Enables Complex Problem Solving

AI performs the prep work. It gathers relevant context, summarizes history, and drafts the technical portions. Humans make the final strategic decisions.

Pain Point Solved: Reduced context-switching. Information comes to you, pre-organized.

5. Creates a Learning Loop

When humans correct AI drafts, those corrections can train the system for better future performance.

Pain Point Solved: The system gets smarter through your natural daily work.

The Comparison: Pure AI vs. Human-in-the-Loop

Metric	Pure AI Triage	Human-in-the-Loop
Speed	Instant	Near-instant (brief review)
Accuracy	85-90%	~100% (human-verified)
Complexity Handling	Simple FAQs only	Professional services ready
Brand Risk	Moderate to High	Low
Efficiency	High	Balanced (speed + quality)

For professional services, client relationships, and any context where a single bad email has real consequences, Human-in-the-Loop isn't a compromise. It's the optimal design.

See It Working

I've deployed the complete system for you to test:

Live Dashboard: ai-email-router.streamlit.app

Upload sample emails or use the test corpus
Watch AI classify in real-time
See generated reply drafts
Review the approval queue workflow

Architecture Diagram: jamal-campbell.github.io/ai-email-router

Visual representation of all components
Swap options for each layer
Current implementation highlighted

Source Code: github.com/jamal-campbell/ai-email-router

Full Python implementation
Modular design for easy adaptation
Version-controlled with changelog

Your Next Step

If you're evaluating AI automation for your business, here's my recommendation:

Don't start with the tool. Start with the workflow.

Map out your current email handling process. Identify where AI can do heavy lifting (classification, drafting, routing) and where humans must remain in control (approval, nuance, relationships).

Then build or adapt an orchestration framework that keeps humans in the loop while capturing AI's efficiency gains.

This demo proves it's not theoretical. It's working today.

Want something like this built for your business? I design and implement AI workflow systems tailored to your operations. Tell me what you're looking to automate →

Framework Version: 2026.1 | Architecture: View Diagram | Demo: Try It

What is AI Tool Orchestration?

2025-12-24T09:00:00-05:00

AI Tool Orchestration (ATO) is the strategic management of all your AI components. Your models, your data pipelines, your APIs, making sure they all work together efficiently and in the right sequence to hit a complex goal.

The value isn't just speed. It's coordination and control.

What Makes It Different?

Going beyond traditional automation frameworks, the greatest distinction with ATO is its reasoning capabilities. It's judgment-based and autonomous.

It doesn't just follow rules. It reasons. It decides which action or tool to use next, based on the dynamic outcome of the previous step and the overall objective.

Key Features

Intelligent Decision-Making

ATO uses AI agents that can perceive, plan, reason, and act. They operate in a continuous loop, constantly adapting based on real-time conditions.

The Agent Loop

How AI agents make decisions continuously

Perceive

Takes in new information from environment, users, or systems

Plan

Determines what needs to happen based on the input

Reason

Decides which tools to use and in what sequence

Act

Executes the planned actions across multiple tools

⚡

AI Agent

Multi-Tool Coordination

Instead of working with isolated applications, ATO connects your entire software stack. Your CRM talks to your email platform, which connects to your analytics tools, all working in sync.

Autonomous Workflows

Once set up, ATO handles complex, multi-step processes without human intervention. It evaluates each situation and determines the best path forward on its own.

Real-World Integration

Through function calling, ATO bridges the gap between AI and your actual business systems. It can check live inventory, update customer records, and interact with external APIs, not just talk about doing work.

Accessible Implementation

Modern low-code platforms have made ATO available to non-technical users. Platforms like Zapier connect with 8,000+ apps, eliminating the need for custom coding.

The Bottom Line

AI Tool Orchestration transforms disconnected tools into a unified, intelligent system. It's not about replacing what you have. It's about making everything work together, autonomously and efficiently.

The result? Businesses see 20-30% reductions in operational costs, 40% productivity boosts, and 50% increases in qualified leads.

That's the power of orchestration.