← Back to portfolio
Completed2024 – Present

Autoteile Data Engine – Competitive Pricing Intelligence & Web Scraping Suite for Automotive Parts

A monorepo of three interconnected Python/PySide6 desktop tools: a web scraper for autoteile-markt.de, a Daparto pricing analysis engine with supplier cost optimization, and an earlier standalone analysis variant — forming a complete pipeline from data collection to pricing intelligence.

Role: Full-Stack Python Developer

Client: Drox Auto (Internal Tooling)

Autoteile Data Engine – Competitive Pricing Intelligence & Web Scraping Suite for Automotive Parts

Problem

An auto parts e-commerce business operating across multiple European platforms (autoteile-markt.de, daparto.de) needs to monitor thousands of competitor prices, analyze market positioning, optimize pricing strategies based on supplier costs, and evaluate new product listing opportunities. Manual price monitoring across platforms with different structures and German-language interfaces is impossible at scale. The business requires an automated pipeline from data collection to actionable pricing intelligence that handles European price formats, brand name variations across platforms, and provides risk-assessed pricing recommendations.

Solution

The Autoteile Data Engine is a monorepo of three interconnected Python desktop applications forming a complete pricing intelligence pipeline. The web scraper (autoteile-markt-Scraping) harvests competitive data from autoteile-markt.de using fast HTTP requests — 4-6x faster than browser automation — with brand/MPN filtering, resume capability across 1,375+ references, and session tracking. The PricePilot analysis engine (autoteile-Daparto-Data-Engine) loads scraped CSV data to provide six analytical views: overview dashboard with Plotly charts, advanced data table with filtering/export, seller position statistics, price gap analysis with risk classification, price optimization with multi-supplier cost matching, and market entry feasibility evaluation. A third variant (Daparto-Data-Engine) represents the original monolithic architecture before refactoring into testable pure functions. All tools share a PySide6 GUI framework, HMAC-SHA256 license protection, and handle the complexities of the German automotive aftermarket including European price formats and brand name normalization.

Tech Stack

Python 3.8+PySide6 (Qt6 GUI Framework)Pandas (Data Processing & CSV Handling)Plotly (Interactive Visualizations)Seaborn (Statistical Plots)Matplotlib (Chart Rendering)Requests (HTTP Client for Scraping)BeautifulSoup4 (HTML Parsing)Playwright (Browser Automation — Backup)HMAC-SHA256 (License Validation)PyInstaller (EXE Packaging)CSV (Data Import/Export)OpenPyXL (Excel Export)JSON (Configuration, Session Data & Brand Mappings)NumPy (Numerical Operations)Kaleido (Plotly Static Image Export)QThread (Background Processing)Logging (File + Console)QtWebEngine (Plotly Chart Rendering)

Architecture

  • Monorepo Structure (3 interconnected tools sharing license infrastructure)
  • MVC Pattern with Pure-Function Core Modules (PricePilot)
  • PySide6 Singleton Pattern for Main Windows
  • MVC-like Separation (core/ for logic, tabs/ for views, ui/ for components)
  • Background Worker Pattern (QThread + Signals + Progress Callbacks)
  • Single-Responsibility Pure Functions (no UI dependencies in calculation modules)
  • Config-Driven Behavior (JSON configs for filters, brand mappings, pricing parameters)
  • Session Persistence (JSON tracking for resume capability across scraper restarts)
  • Shared License System (HMAC keygen with identical secret across tools)
  • Modular CSS/Stylesheet System (Fusion style with dark/light themes)
  • Event-Driven GUI with Signal/Slot Connections
  • Column Mapping Dialog for Flexible Supplier CSV Import
  • Brand Normalization Pipeline (platform brand → supplier brand mapping)
  • European Price Format Parser (comma decimals, € symbols, 'kostenlos')
  • HTTP Connection Pooling for Scraping Speed
  • Session-based Request Management with Automatic Cookie Handling
  • Worker Thread Pattern for Heavy Calculations (non-blocking UI)
  • Progress Callback Pattern (percent, message) for All Background Workers
  • Risk Classification System (Low/Medium/High/No Competitor thresholds)
  • Landed Cost Calculation Pipeline (supplier price + transport + commission)
  • Market Entry Status Determination (Competitive/Not Viable/Position Gap)
  • Monolithic Worker Architecture (DataTitan predecessor variant)
  • Pure Function Architecture (PricePilot evolved variant)
  • CSV Chunking for Large Dataset Handling (1.25M+ rows tested)

Features

Web scraper for autoteile-markt.de using HTTP requests (4-6x faster than Playwright browser automation)

Resume capability via session_data.json (skips already processed references on restart)

Brand filtering based on Hersteller sidebar filter with configurable brand list

MPN filtering to match reference within manufacturer part numbers

Single-offer scraping directly from product card

Multi-offer scraping by navigating to product details page for all sellers

CSV output with product_reference, brand, MPN, seller_name, price, shipping, delivery_time

Input references from CSV file with automatic unprocessed reference detection

Session tracking: processed, not_found, failed, and empty reference categories

PySide6 GUI with References, Filters, Run, Output, and About tabs

Real-time log widget with splitter layout for live scraping feedback

Background worker threads (QThread) for non-blocking scraping operations

License keygen system with HMAC-SHA256 validation (shared across scraper and PricePilot)

Price analysis desktop app (PricePilot) with 6-tab analytical interface

Overview dashboard with statistics and interactive Plotly charts (5 chart types)

Data Table with advanced filtering, search, and CSV/Excel export

Seller View with position statistics per brand (price ranking within product groups)

Price Gap analysis for position #1 products with 4 risk levels (Low/Medium/High/No Competitor)

Price Optimizer with multi-supplier CSV upload, column mapping, and 5 pricing strategies

Market Entry analysis for evaluating new product listing feasibility

Supplier price matching with brand normalization via brand_mappings.json

Configurable pricing parameters (transport cost, min profit, platform commission, price gap)

Background processing workers for all heavy calculations with real-time progress bars

Plotly visualizations: price distribution, top sellers, competitive products, delivery time, shipping pie

Brand Mappings settings dialog for platform-to-supplier brand name matching

CSV and Excel export with filter/sort respect

Standalone analysis variant (DataTitan-Daparto) with Seaborn and Matplotlib support

EXE build scripts (PyInstaller) with .spec files for all three tools

Windows batch scripts for setup, activation, and building

Configurable brand filter and MPN filter via JSON configuration files

Error handling with failed reference tracking and retry capability

European price format handling (comma decimals, € symbols, 'kostenlos' free shipping)

Seller name normalization and deduplication across marketplaces

Shipping cost normalization (free vs paid detection)

Delivery time extraction from German-language page elements

Cross-platform compatible (Windows, Linux, Mac)

Modular MVC architecture: core logic separated from UI and workers

Single-responsibility pure functions for all calculation modules

PySide6 Fusion style with custom dark/light stylesheet

Column mapping dialog for flexible supplier CSV import

Position statistics ranking sellers by price within product groups

Risk level classification system for price gap analysis (Low/Medium/High/No Competitor)

Three pricing strategies: lowest supplier price, highest supplier price, and average

Landed cost calculation: supplier price + transport cost + platform commission

Market entry status categories: Competitive, Not Viable, Position Gap

Interactive Plotly charts rendered in PySide6 web views

Session-based request management with automatic cookie handling

Progress callback pattern (percent, message) for all background workers

About this project

The Autoteile Data Engine is a monorepo containing three interconnected Python desktop applications built for the automotive parts industry. The ecosystem forms a complete pipeline from data collection to pricing intelligence, addressing the challenge of monitoring thousands of competitor prices across German auto parts platforms.

The web scraper (autoteile-markt-Scraping) uses fast HTTP requests to harvest product data from autoteile-markt.de — 4-6x faster than the original Playwright browser automation approach. It processes 1,375+ product references from a CSV input file, searches each reference on the platform, applies brand and MPN filters from JSON configuration, and extracts seller data including name, price, shipping cost, and delivery time. The scraper handles both single-offer products (scraped directly from the product card) and multi-offer products (navigating to the details page to extract all sellers from the 'Alle Anbieter zum Ersatzteil' section). Session tracking via JSON files enables resume capability, so interrupted scraping runs continue where they left off.

The PricePilot analysis engine (autoteile-Daparto-Data-Engine) is a PySide6 desktop application with a 6-tab analytical interface. The Overview tab provides a statistics dashboard with interactive Plotly charts — price distribution histograms, top seller bar charts, competitive product scatter plots, delivery time analysis, and shipping cost pie charts. The Data Table tab offers advanced filtering, search, and CSV/Excel export for exploring raw market data with 1.25M+ row support.

The Seller View tab computes position statistics — how many times a seller appears at each price rank (1st, 2nd, 3rd, etc.) within each brand group, with brand filtering and export capabilities. The Price Gap tab analyzes products where the seller holds position #1, calculating the gap to position #2 and classifying risk levels: Low Risk (safe to increase price), Medium Risk (caution), High Risk (not recommended), and No Competitor (free to increase). The Price Optimizer tab is the most complex — it accepts seller selection, multiple supplier CSV files with interactive column mapping, and pricing parameters (transport cost, minimum profit, platform commission, price gap). It computes recommended prices for every product where the seller isn't already #1, with three statuses: 'Go for #1' (profitable underbid possible), 'Sell at minimum' (floor price), and 'Can't be #1' (floor above market price).

The Market Entry tab evaluates whether new products from supplier catalogs should be listed on the platform, computing minimum profitable prices against existing market data, recommending entry strategies with position and profit analysis. All heavy calculations run in background QThread workers with real-time progress bars, keeping the UI responsive even with massive datasets.

A third variant (Daparto-Data-Engine, branded 'DataTitan-Daparto') represents the original monolithic architecture — same 6-tab feature set but with business logic embedded directly in worker thread methods rather than separated into testable pure-function modules. This served as the predecessor that was refactored into the modular PricePilot architecture.

All three tools share a PySide6 GUI framework with Fusion styling, custom stylesheets, and a modular architecture. A shared HMAC-SHA256 license system protects commercial use, with a keygen tool that generates time-limited keys accepted by both the scraper and analysis engine. The system handles the complexities of the German automotive parts market: European price formats with comma decimals, 'kostenlos' (free) shipping detection, brand name normalization across platforms, seller name deduplication, and delivery time extraction from German-language page elements.

Challenges

  • Building a web scraper that handles both single-offer and multi-offer product pages with different DOM structures
  • Implementing resume capability across 1,375+ references with session persistence via JSON files
  • Parsing European price formats (comma decimals, € symbols, 'kostenlos' free shipping detection)
  • Normalizing brand names across platforms (e.g., 'BM Catalysts' → 'BM', 'ESEN SKV' → 'SKV')
  • Building a price optimization engine that matches supplier costs to market data with 5 pricing strategies
  • Implementing position statistics that rank sellers by price within product groups across all brands
  • Creating a price gap analyzer with 4-tier risk level classification based on percentage thresholds
  • Building a market entry analyzer that evaluates feasibility against existing market competition
  • Designing a column mapping dialog for flexible supplier CSV import with different column orders
  • Implementing background workers with real-time progress for all heavy calculations
  • Sharing an HMAC-SHA256 license keygen system across multiple tools with identical secrets
  • Handling large datasets (1.25M+ rows) efficiently in a desktop GUI with chunked CSV loading
  • Creating Plotly visualizations that render correctly in PySide6 QWebEngineView widgets
  • Building EXE packages with PyInstaller for distribution across Windows machines
  • Designing a modular architecture that separates pure calculation logic from UI for testability
  • Refactoring monolithic workers into single-responsibility pure functions (PricePilot evolution)
  • Handling HTTP session management with automatic cookie handling for authenticated scraping
  • Extracting delivery time information from German-language page elements
  • Implementing landed cost calculation with transport cost, platform commission, and minimum profit margins
  • Creating a seller name normalization pipeline to handle variations across marketplace listings

Results

  • Complete web scraper for autoteile-markt.de with 4-6x speed improvement over browser automation
  • Resume capability processing 1,375+ references with session tracking across restarts
  • Price analysis engine (PricePilot) with 6 analytical views and interactive Plotly visualizations
  • Position statistics ranking sellers by price within product groups across all brands
  • Price gap analysis with 4-tier risk classification (Low/Medium/High/No Competitor)
  • Price optimization with multi-supplier cost matching and 5 pricing strategies
  • Market entry feasibility analysis with 3 status categories (Competitive/Not Viable/Position Gap)
  • Interactive Plotly visualizations (5 chart types) rendered in PySide6 web views
  • CSV and Excel export with filter/sort respect across all analysis tabs
  • Shared HMAC-SHA256 license protection system across all tools
  • EXE distribution packages for Windows via PyInstaller
  • Modular codebase with pure-function architecture (testable, maintainable)
  • European price format handling (German market: comma decimals, € symbols, 'kostenlos')
  • Background processing with real-time progress feedback for all operations
  • Configurable brand mapping system for cross-platform name matching
  • Large dataset support tested with 1.25M+ rows via chunked CSV loading
  • Column mapping dialog for flexible supplier CSV import
  • Risk classification system for informed pricing decisions
  • Landed cost calculation with transport, commission, and margin parameters
  • Successfully evolved from monolithic to modular architecture (DataTitan → PricePilot)

Community

GitHub

Social Media

Linkedin
© Taoufik Boucetta 2026 Inc. All rights reserved.