Dynamic repricing against competitors

The company runs a dynamic repricing process to keep product prices competitive within defined margin constraints. A few times per week, the two-person operations team and founder manually check competitor prices for key products, then compare those prices against the current Shopify catalog and the company's margin rules. They decide which prices need adjustment, update Shopify directly, and document the changes in spreadsheets or custom scripts. Each repricing session takes around ninety minutes, and the team runs roughly two hundred and sixty of these sessions per year. About a quarter of cases involve non-standard judgment calls, such as unclear competitor data or edge cases that fall outside the usual margin logic, and the team sometimes needs to fix errors from earlier manual updates.

The process relies heavily on Shopify as the primary system for storing and publishing product prices. Supporting tools include custom scripts for price tracking, spreadsheets for logging decisions, and email for coordination. The founder has coding experience and has already built some lightweight automations, so the team is comfortable with technical solutions. The company must comply with consumer pricing law and GDPR for customer data, but neither imposes unusual constraints on repricing automation.

The manual workflow consumes significant time on repetitive tasks that follow clear rules, and the team recognizes that most routine cases could run automatically if competitor data and margin logic were encoded in a script. The goal is to automate the straightforward repricing decisions and free the team to focus on the exceptions that genuinely need human judgment.

Traditional code is the right solution for this repricing process because the decision logic is deterministic, the data is structured, and the team already has the technical capability to build and maintain a custom script. The core task is to compare competitor prices against current Shopify prices, apply explicit margin rules, and update prices within bounds. That is a textbook fit for a rule-based script with no need for machine learning or probabilistic reasoning. The Shopify API is mature and well-documented, so reading and writing prices programmatically is straightforward, and the founder's coding experience means the solution can be built in-house without vendor lock-in or ongoing licensing fees.

The recommendation aligns perfectly with the stated preference for Shopify plus custom scripts. The team already runs some automations, so adding a repricing script fits naturally into the existing infrastructure. Building on the Shopify API rather than using RPA to automate the browser interface gives you a cleaner, faster, and more maintainable solution. If a competitor changes their site layout or Shopify tweaks its UI, an API-based script keeps working while an RPA bot would break and need repair. The cost difference is also significant: a custom script costs three to six thousand euros to build and nothing ongoing, while RPA tools charge annual licenses and fragile bots need constant tuning.

AI workflow orchestration and autonomous agents score low here because they add complexity and cost without improving accuracy. The margin rules are explicit, so there is nothing for a model to learn or predict. An AI agent might sound appealing in the abstract, but in practice it would introduce latency, obscure the decision logic, and raise the risk of unexplainable pricing errors. Pricing mistakes directly affect revenue and customer trust, so transparency and control matter more than flexibility. A deterministic script lets you audit every decision, roll back mistakes instantly, and tune the rules with a few lines of code.

The twenty-five percent exception rate is manageable with a flag-for-review design. The script handles the routine cases where competitor prices are clear and margin rules apply cleanly, then surfaces the non-standard cases to the ops team with full context. That gives you the automation benefit on the seventy-five percent of volume that is repetitive while keeping human judgment in the loop for the cases that need it. The hybrid score is high because this flag-for-review pattern is effectively a hybrid approach, but it is baked into the traditional code recommendation rather than requiring a separate orchestration layer.

Staying manual would waste three hundred and ninety hours per year on work a script can do faster and more consistently. The payback period is under two months, and the team gets their time back to focus on the judgment calls and strategic decisions that actually need a human. The recommended path is low-risk, low-cost, and plays directly to the technical strengths already present in the organization.

Traditional Code wins because the decision logic is deterministic and the data is structured. You have explicit margin rules, numeric price inputs, and a mature Shopify API, which means a straightforward script can scrape competitor prices, apply the logic, and push updates automatically. There's no pattern recognition or ambiguity that would benefit from AI, so AI Workflow and AI Agent add cost and complexity without improving accuracy. RPA could technically work by automating the browser clicks, but it's more brittle than a native API integration and costs more to license and maintain. When you already have an API and in-house coding ability, screen scraping your own Shopify admin is the long way around.

Hybrid scores well because it layers a human approval gate on top of the automated rule checks, which is sensible for pricing decisions that directly affect revenue. The reason Traditional Code edges it out is that your exception handling already includes flagging non-standard cases for review, so the human gate is effectively built into the recommended design. You get the safety of hybrid without forcing approval on every routine change. Staying Manual is the worst option here because you're burning 390 hours a year on repetitive lookups and updates that a script can handle in seconds, and you have the technical chops to build it.

The implementation starts with building a competitor price collector. Identify your top three to five competitor sources and write a script that pulls their prices daily or on-demand. If they offer structured data feeds or APIs, use those. If not, scrape their public product pages using a tool like BeautifulSoup or Puppeteer. Store the results in a lightweight database like SQLite or a Google Sheet if the volume is modest. This collector runs on a schedule and keeps a rolling snapshot of competitor pricing, which becomes the input for your repricing logic.

Next, encode your margin rules and repricing algorithm. The script reads current Shopify prices via the API, compares them to the latest competitor data, and calculates the optimal new price within your margin boundaries. For straightforward cases where the new price is clearly within bounds and matches your competitive positioning, the script queues an automatic update. For edge cases, like prices that would violate margins, products with unclear competitor matches, or SKUs flagged as high-sensitivity, the script writes to an exceptions queue with context. The ops team reviews that queue daily and approves or adjusts those cases manually.

The Shopify integration is the final piece. Use the Shopify Admin API to read product and variant prices and write updates back for approved changes. Wrap this in a simple dashboard or notification system, perhaps a Slack channel or email digest, that surfaces flagged exceptions with links to the relevant products and competitor data. Include logging for every price change with a timestamp, old price, new price, and reason, so you have a full audit trail. Run the system in pilot mode on a small subset of SKUs for two to three weeks, monitor for errors and false positives, then expand to your full catalog once the team is confident in the logic.