A solo-built, API-first prototype demonstrating how deterministic financial decision systems can be designed with built-in explainability, audit persistence, and strict reproducibility guarantees.
This is a systems architecture prototype — not a production fintech platform.
The Deterministic Decisioning Engine:
- Accepts structured application inputs
- Applies fixed, rule-based deterministic logic
- Generates structured decisions and risk scores
- Persists complete request/response audit records
- Guarantees identical output for identical input
All decision events are stored with rule version tracking to ensure traceability.
Many automated decision systems lack:
- Reproducibility (hidden state, probabilistic models)
- Structured explanation outputs
- Complete audit storage of input/output payloads
This prototype explores how those concerns can be addressed using:
- Deterministic rule logic
- API-first architecture
- PostgreSQL audit persistence
- Explicit rule version tracking
No machine learning is used.
- Deterministic rule engine
- Score generation (0–1000)
- Decision mapping (APPROVE / REVIEW / REJECT)
- Structured reason codes
- Template-based explanation generation
- PostgreSQL (Railway-managed) audit persistence
- Full request + response JSON storage (JSONB)
- FastAPI REST API
- Streamlit demo UI (Python-only)
- Determinism validation mechanism
- Authentication / user accounts
- Machine learning models
- External bureau integrations
- Multi-tenancy
- Rate limiting
- CI/CD pipelines
- Production hardening
- Regulatory compliance claims
- Backend: FastAPI (Python 3.10+)
- Database: PostgreSQL (Railway-managed)
- ORM: SQLAlchemy
- Frontend: Streamlit (Python-only client)
- Communication: REST (JSON over HTTP)
Streamlit UI
↓
POST /apply (FastAPI)
↓
Input Validation (Pydantic)
↓
Deterministic Rule Engine
↓
Persist to PostgreSQL (JSONB audit record)
↓
Structured Response Returned
Audit retrieval:
Client → GET /audit/{audit_id} → Return stored record (no recomputation)
Evaluates structured application input.
Input Fields
- income_monthly
- dti
- employment_months
- age
- has_defaults
Response Fields
- audit_id (UUID)
- decision (APPROVE / REVIEW / REJECT)
- score (0–1000)
- reason_codes
- explanation
- rule_version
Retrieves stored audit record.
Returns:
- request_json
- response_json
- rule_version
- created_at
Decision is never recomputed on retrieval.
Returns:
{ "status": "ok" }
The system guarantees:
- No randomness
- No time-based evaluation logic
- No external API dependencies
- Pure rule evaluation
- Identical input → identical decision & score
Only audit_id and timestamp differ across identical submissions.
Export your Railway PostgreSQL connection string:
export DATABASE_URL="your_railway_postgres_connection_string"python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --reloadAccess API docs at:
http://127.0.0.1:8000/docs
streamlit run ui/streamlit_app.pyThe full documentation suite includes:
- PRD.md — Product requirements
- APP_FLOW.md — User interaction flows
- TECH_STACK.md — Technology decisions
- BACKEND_STRUCTURE.md — Backend architecture
- FRONTEND_GUIDELINES.md — UI design constraints
- IMPLEMENTATION_PLAN.md — Build roadmap
All documents are structurally aligned and reflect the current architecture.
This project is not:
- A real credit scoring engine
- A licensed financial product
- A production-ready system
- A regulatory-certified platform
- A SaaS deployment
It is a deterministic systems design prototype built for architectural clarity and technical evaluation.
Last Updated: 2026-02-12