I Built HelloBible's Voice of Customer Pipeline for ~$2 a Month.

HelloBible had no reliable way to compare recurring bugs, feature requests, and churn-risk signals across channels. Which bugs are recurring? What do users actually want next? Who’s threatening to churn? Nobody could tell you without spending half a day in raw text - so people stopped checking.

The pipeline centralises and classifies feedback from the 4 channels monthly. 2,020 verbatims classified across 27 business-specific themes, for ~$2 in API costs. I deliver one monthly CSV and one CEO readout, both fed by what users actually say rather than what’s top-of-mind in the last meeting.

The friction I found

HelloBible had feedback flowing in from 4 places, none of which talked to each other:

• Zendesk support tickets (1,145 in 2026)
• WhatsApp beta group (516 messages, 8 months of scrolling history)
• Google Play Store reviews (326)
• App Store iOS reviews (33 from 2026 out of 118 pasted manually)

Tickets got read one by one. Store reviews were checked in each app’s interface. The WhatsApp group was scrolled manually when someone remembered to. No taxonomy, no priority signals, no shared way for the team to talk about users.

The decisions that depended on this data were getting made on intuition. Which bugs are recurring? What features do users actually want? Who’s threatening to churn? Nobody could tell you without spending half a day in raw text.

What I actually built

A 6-step Python pipeline that runs monthly:

1. Export Zendesk via the Incremental API (full tickets + every comment in every conversation)
2. Parse the WhatsApp _chat.txt export (with a robust regex that handles names containing colons - my first version broke on something like ”~ Jean 3:16”)
3. Integrate monthly Google Play Store CSVs (with UTF-16 BOM handling because of course they ship it that way)
4. Append App Store iOS reviews (manually copy-pasted, because there’s no public reviews API for iOS)
5. Classify every verbatim via Claude Haiku 4.5 against a 27-theme taxonomy I designed and iterated
6. Output two artifacts: a CSV for the team to explore and filter, a Markdown executive synthesis for the CEO

The whole thing runs from a single command. State is checkpointed every 100 records, so a failed run resumes from where it stopped instead of forcing a full reclassification.

How it costs ~$2 a month

Pipeline design choices that keep the cost down:

• Deterministic pre-filter on message length and content type (saves ~14% of LLM calls)
• Claude Haiku 4.5 for bulk classification, not a larger model
• Ephemeral cache on the taxonomy system prompt (amortized across all calls)
• Checkpointing every 100 records (a crash doesn’t re-run already-classified records)

Total cost for 1,703 classifications: ~$2 in API calls. The technical details are in the accordion below.

1. export_zendesk_2026.py     → zendesk_tickets_2026.jsonl     (1,145 tickets)
2. consolidate_voc_2026.py    → voc_unified_2026.jsonl         (2,020 verbatims)
3. classify_voc_haiku.py      → voc_classified_2026.jsonl      (theme + sentiment + signal)
4. [dedup + export CSV]       → voc_classified_2026_final.csv  (Google Sheets)
5. [executive synthesis]      → VoC_HelloBible_2026.md         (CEO read)
6. run_monthly_voc.py         → orchestrates 1-5 every month

What broke (the useful ones)

The bugs worth telling about - not the typos, the ones that taught me something:

• WhatsApp regex broken on colons in names like ”~ Jean 3:16”. The first split on : captured the Bible reference as the message body. Fix: split on the first ": " pattern instead.
• Haiku appending text after the JSON object caused json.loads to fail with “Extra data”. Fix: regex-extract the first JSON object instead of parsing the whole response.
• Hit the monthly Anthropic API limit at record 650/1,703 mid-classification. Bumped the limit, the script resumed from the checkpoint. The resumable design worked as intended.
• Partial stats + 51 duplicates after resume because the stats dict reset on each run. Claude Opus was used to audit classification consistency and flagged that my numbers didn’t add up arithmetically. Regenerated a clean deduplicated CSV.

What this changes operationally

Before the pipeline, deciding what to build next at HelloBible relied on individual memory and whatever feedback was freshest. Now the team has the data to answer three concrete questions every month:

• What’s bothering users right now? (filter the CSV by sentiment: negative and recurring themes)
• What do users actually want next? (filter by signal: feature_request and roll up by theme)
• Who’s about to leave? (filter by signal: churn_risk and surface in support)

The exec gets a 1-page Markdown synthesis. The product team gets the full CSV to dig into. Same data, two artifacts, ~$2 a month to keep both fresh.

The taxonomy standardised how recurring issues and requests are categorized internally. The pipeline refreshes it every month from a single Python command.