Step-by-step: How we reduced Hailuo costs by 30% with better caching.

Our team has been using Hailuo for batch processing of media assets (image resizing, video transcoding) for about eight months. While impressed with the throughput and API consistency, our monthly spend was tracking 40% above initial projections as volume grew. A detailed cost analysis revealed that nearly 65% of our processing tasks were redundant transformations on assets that had already been processed in the last 30 days. This post details the caching layer we implemented to address this, which reduced our Hailuo compute costs by 30.2% over the last billing cycle.

The core insight was that our system was issuing Hailuo jobs without checking if a valid output already existed. The transformation parameters (source URI, target dimensions, codec settings, etc.) formed a deterministic key. We implemented a two-tier caching strategy: a fast, in-memory check for high-frequency assets and a persistent, fallback database record for all processed jobs.

**Architecture Overview:**
1. **Request Interceptor:** All calls to the Hailuo client library are routed through a wrapper that first generates a cache key.
2. **Cache Key Generation:** We use a SHA-256 hash of a canonical JSON string of all job parameters. This ensures consistency.
3. **Cache Lookup Logic:** Check Redis (Tier 1) for the hash key. If missed, check PostgreSQL `processed_jobs` table (Tier 2).
4. **On Cache Hit:** Immediately return the stored output URI and metadata, bypassing the Hailuo job entirely.
5. **On Cache Miss:** Submit the job to Hailuo, and upon successful completion, write the result to both Redis (with a 7-day TTL) and PostgreSQL (persistent).

**Key Implementation Details:**

The cache key is critical. We sort parameters alphabetically to ensure the same logical job always produces the same hash.
```python
import hashlib
import json

def generate_job_cache_key(source_uri: str, params: dict) -> str:
"""Generate deterministic cache key for a Hailuo job."""
canonical_dict = {
"source": source_uri,
"params": {k: params[k] for k in sorted(params.keys())}
}
canonical_string = json.dumps(canonical_dict, sort_keys=True, separators=(',', ':'))
return hashlib.sha256(canonical_string.encode()).hexdigest()
```

The database schema for the persistent record includes audit information.
```sql
CREATE TABLE processed_jobs (
cache_key CHAR(64) PRIMARY KEY,
source_uri TEXT NOT NULL,
parameters JSONB NOT NULL,
output_uri TEXT NOT NULL,
hailo_job_id UUID,
created_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE INDEX idx_source_uri ON processed_jobs(source_uri);
```

**Cost Impact & Benchmarks:**

We conducted a 14-day A/B test, routing 50% of traffic through the new caching layer. The results were clear:

* **Cache Hit Rate:** 62.3% (validating our initial cost analysis)
* **Reduction in Hailuo Job Count:** 58.1%
* **Overall Cost Reduction:** 30.2% (note: cost reduction is less than job reduction due to tiered pricing and large job variance)
* **Added Latency on Cache Hit:** ~12ms (Redis lookup) vs. average job time of 4.7 seconds.
* **Storage Trade-off:** The S3 storage cost increase for storing persistent outputs was negligible (approx. 1.2% of the savings).

**Pitfalls & Considerations:**

* **Cache Invalidation:** This is a read-heavy, write-through cache. We only invalidate on manual business request (e.g., asset re-processing). For our use case, this is acceptable.
* **Parameter Sensitivity:** Ensure all parameters that affect the output are included in the key. We initially omitted the `quality` setting, which led to incorrect cache hits.
* **Idempotency:** Hailuo's API is idempotent, which aligns perfectly with this pattern. We reused the cache key as the idempotency key for the Hailuo API where applicable.

The implementation required approximately three developer-weeks but paid for itself in less than a month. The system is now more scalable and performs significantly better for end-users receiving cached results. The same pattern should be applicable to any deterministic batch processing pipeline.

-ck