Flower Shop

Overview

A partly built module covering orders, products, notifications and task automation. We finished it for production use. The business runs daily operations on scheduled reminders, an external commerce catalogue and AI-generated task lists. A silent failure in any of those flows means missed work and out-of-date stock information.

Challenges

The module had the right shape but it wasn't reliable. Task reminder emails never rendered because their templates were missing. The scheduled jobs meant to send them were never activated so recurring reminders failed silently. When reminders did go out staff received one email per task. Useful information turned into noise. Manual reminder commands behaved differently from the scheduled ones. The same request produced different results depending on how it was triggered. Product webhooks from the external commerce system were accepted but never processed. Store synchronisation didn't exist at all. Local pricing, stock and status data drifted away from reality. External API calls had no retry logic so one momentary network failure broke synchronisation outright. Production code still printed debug output instead of writing usable logs. Webhook secret validation could be skipped in production. That left order intake open to unverified payloads. AI task generation collapsed whenever the vendor returned malformed JSON or an odd date format. It fell back to generic placeholder tasks. A duplicated multi-endpoint webhook design made single-target delivery impractical. And downstream order processing carried an undefined-variable error waiting to fire.

Solution highlights

We finished the unfinished flows and hardened what surrounds them. Notifications were rebuilt on reusable templates with shared rendering logic. They now go out as a single digest per recipient instead of one message per item. The background scheduler was activated and verified. Manual commands point at the same digest and template service so both paths behave the same. On the commerce side we built real product create, update and delete synchronisation plus a store metadata sync service. Consistency handling covers pricing, stock, status and deletions. External calls gained retry and backoff. Print statements were replaced with structured logging that tracks success rates, failure rates and last-sync timestamps. AI task generation was rebuilt with response parsing, date normalisation, validation and a context-aware fallback. When the vendor misbehaves that fallback produces useful tasks rather than generic ones. We replaced the duplicated webhook endpoints with one shared service. It handles validation, parsing, routing and fan-out through a single order-event endpoint. Backward compatibility was kept so the cutover could be done safely.

Key Features

• Scheduled notifications for daily, upcoming, incomplete and completion-based task reminders
• Reusable notification templates with dynamic variables and shared rendering
• Consolidated digest notifications that group multiple items into one message per recipient
• Background scheduler activation for all recurring reminder jobs
• Product create, update and delete synchronisation from the external commerce system
• Store and account metadata synchronisation with consistency handling
• Retry and backoff on all external API communication
• Structured sync logging covering success rates, failure rates and last-sync timestamps
• AI-assisted task generation with parsing, date normalisation and context-aware fallback
• Shared webhook service with a single order-event endpoint and downstream fan-out
• Enforced webhook signature verification in production
• Integration and regression testing plus configuration documentation

Our Role & Approach

This was a stabilisation job rather than a greenfield build. Our role was to turn partly implemented flows into production-ready services. We didn't change what the business already understood about how the system worked. We prioritised by blast radius. Silent failures came first: missing templates, inactive jobs and unprocessed webhooks. Then data integrity through sync drift, retries and logging. Then security with webhook verification. Then developer experience through shared services, dead code removal and documentation. We introduced a shared service layer for webhooks instead of patching each endpoint. The duplication was the root cause rather than a symptom. Backward compatibility and migration testing were planned from the start so the webhook cutover could happen without an outage.

Technology Stack

Backend: Django, Django REST Framework, Celery and scheduled background jobs. Integrations: external commerce platform webhooks and APIs, AI vendor APIs. Infrastructure: structured logging, retry and backoff handling, signature-verified webhook intake. Quality: integration and regression test coverage, technical documentation for sync and webhook configuration.

Outcomes

Reminder emails render reliably and recurring jobs run on schedule. Staff get the task reminders they depend on. Recipients now get one clean digest per cycle instead of a stream of duplicates. That cut inbox noise without losing any information. Scheduled jobs and manual commands behave identically. A long-standing source of confusion is gone. Local product and store data stays consistent with the external commerce system across pricing, stock, status and each create, update and delete. Synchronisation survives transient failures thanks to retry and backoff. Operators can monitor health directly through structured success, failure and last-sync logging. Order intake is materially safer in production with enforced signature verification and one predictable endpoint feeding multiple internal pipelines. AI-generated tasks degrade gracefully with useful context-aware fallbacks instead of failing outright. A duplicated webhook design, a runtime error in order processing and several dead code paths are gone. End-to-end coverage plus configuration documentation gives the team confidence that the whole chain works together.