Snap Remedy / Full-stack development
ERP integration and product ranking
I developed the Django backend and React frontend for an application that turns ERP records and manually supplied inputs into configurable product rankings.
The application
Users configure comparisons through filters and factor weights, then review each finished-goods SKU’s score and supporting data.
Application architecture
Application data flow
Source data
ERP recordsManual CSV inputs
Ingestion
ETL and synchronizationValidation and imports
Relational storage
Application dataPersistent sync progress
Scoring and APIs
Deterministic rankingDjango JSON APIs
React interface
Comparison controlsRankings and details
Optional explanations
Ranking context LLM integration and cache Result details
LLM output does not calculate or change scores.
Separate external-data viewer
External data Storage and APIs Charts and tables
No input to SKU scoring.
Data modeling and ERP integration
I built dataset-specific ETL adapters to map ERP payloads into Django models, convert values consistently, and resolve required relationships.
I normalized repeated data into related records and used stable external identifiers and uniqueness constraints for repeatable imports. Retaining source payloads alongside queryable fields supported mapping diagnostics.
Ranking queries the local database independently of synchronization, avoiding ERP requests during calculation.
Resumable synchronization
I implemented a shared synchronization runner with paginated fetching, bounded retries for temporary failures, and persistent checkpoints. Datasets run in dependency order.
Checkpoints track page progress; writes commit in smaller transaction chunks. If a later chunk fails, committed chunks remain and the checkpoint stays on that page. Resume replays the page through stable-key upserts that update existing records instead of inserting duplicates.
Status and recovery APIs expose progress and failures. Synchronization runs synchronously and supports checkpointed replay; it does not provide exactly-once processing. Recovery changes stored state without terminating a running process.
Configurable SKU ranking
I implemented deterministic scoring with configurable weights, normalization, filtering, and stable tie ordering. Database-side aggregation prepares the inputs; Django APIs return scores and the values used to calculate them.
The response identifies unavailable factors and reports completeness separately from the score. Missing-data rules distinguish unavailable inputs from low values.
The API supports eight factors; seven have React controls. The remaining factor is API-only. Optional LLM explanations use completed ranking context without calculating or changing scores. Context-based caching reuses explanations; provider failures can be returned alongside valid rankings.
Full-stack integration
I built React controls for filters and weights, ranking requests, and expandable results, connected to Django JSON APIs.
CSV imports provide row-level validation and a write-free preview. Confirmation revalidates the file and commits changes atomically, rolling back the import on a write failure.
A separate external-data workflow stores observations and exposes them through APIs for charts and tables. It does not feed SKU scoring.
Testing and validation
I wrote backend tests for mapping, relationships, scoring, filters, API validation, and explanation caching. Failure-path tests cover retries, checkpoint replay, partial commits, and CSV rollback.
The documented suite contains 185 tests; its recorded run used an isolated in-memory database and mocked providers. These results describe local backend behavior. I documented scoring rules, APIs, and synchronization recovery for handoff.