BBE Marketing

We're hiring full-time developer to build and maintain our Python/Flask platforms that collects data from a growing list of websites. We're looking for an engineer to own that data end to end: collecting it reliably, structuring it well, analyzing it with AI, and exposing it through APIs that our other applications depend on.

What you'll do
 

1. Scraping

• Add new sites to the scraper. Analyze each target site's structure, write parsers with BeautifulSoup4, and map the extracted data into our database models.
• Maintain existing scrapers. Diagnose and fix breakages caused by layout changes, new anti-bot measures, or changed endpoints.
• Work with our adaptive HTTP client. Our client falls back through curl_cffi → httpx → requests → hrequests. You'll tune it per site, handling headers, cookies, sessions, TLS/browser impersonation, and retries.
• Keep daily runs dependable. Add logging, alerting, and failure reporting to our scheduled jobs so problems surface quickly.

2. Database design

• Design clean, scalable schemas. Model scraped data with proper normalization, keys, constraints, and indexes, balancing data integrity against query performance.
• Manage schema changes safely. Use migrations (Alembic / Flask-Migrate) across SQLite in development and PostgreSQL in production.
• Protect data quality. Validate, normalize, and deduplicate data so that everything built downstream can rely on it.

3. AI and data analysis

• Turn raw data into insight. Analyze scraped data to find trends, anomalies, and patterns that matter to the business.
• Apply LLMs where they add value. Use models such as Claude or GPT for classification, summarization, entity extraction, and structured output from unstructured text.
• Improve how our AI reasons. Design and iterate on prompts, define structured output schemas, build evaluation sets, and measure accuracy so AI results get better over time, not just different.
   

4. APIs and integration

• Build APIs for our other applications. Design and implement well-documented REST APIs in Flask with consistent request and response schemas, versioning, pagination, and error handling.
• Secure and scale them. Implement authentication, rate limiting (Flask-Limiter), and input validation, and document endpoints with OpenAPI/Swagger.

We run an internal data platform behind a talent representation intelligence product that maps out the entertianment industry.
 

We are rebuilding the platform (legacy Symfony/Angular → Django + React) because the current system stores its most valuable data as unstructured text and can't support where the product is going. . This is not a greenfield toy and not a rescue job — it's a planned rebuild with an unusual amount of groundwork already done:

• A product & architecture document with the domain model decided: what each module means, what dies, what changes, and the conventions (append-only history, structured-at-entry, derived-values-never-facts, and more)
• An epic breakdown with dependency order and explicit definitions of done
• A decisions register — every product ruling logged, searchable, current
• Approved feature specs for the major new modules (representation history, deals/endorsements restructure, awards, drafts)
• A migration standard: raw-row archives, legacy-ID mapping, conflict review queues, rehearsed cutover — nothing silently dropped, nothing silently merged
   

Your job is to design and build within that system: propose schemas and migration plans per module (we call these build contracts — you propose, product approves, then you build), stand up the foundation (auth, field-level permissions, API-first architecture), build the cross-cutting primitives (audit log, unified sources, soft delete, lookups), and run a phased legacy migration where reconciliation counts get reviewed, not just produced.
 

How we work — read this part twice:

• The documents are the spec; the legacy code is not. Many current features are unused and several database tables are mislabeled (we've mapped this). When you hit a question about what something should do, you ask — you don't resolve it from old code. We answer questions daily, in writing, fast.
• Gates are real. Every epic starts with your proposed schema + migration plan; implementation starts after approval. Epics close when their definition-of-done closes — including a researcher completing the workflow without your help — not when the tasks are checked off.
• AI tooling is welcome and expected. We assume you'll use agents/copilots — we do. What we hire for is what the tools can't do: judgment. You verify what your tools produce against the real schema and the real data before it reaches us. "The agent said so" is not a source. (Our favorite recent bug: a generated diagram claiming a name column was an integer. The person who catches that is who we're hiring.)
• Evidence over memory. Unknowns get investigated — code usage, row counts, what breaks — and then ruled on. We don't guess.
  
  You're a fit if:
• Senior Django + React, with real ownership of at least one system end-to-end (schema through UI through deployment)
• You've done at least one legacy migration or system replacement and can talk concretely about what went wrong and what you'd do differently
• You read before you build — genuinely. Our last mismatch was a capable developer who never opened the app or the documents; the interview is designed to detect this, so if it's not you, save us both the call
• You're comfortable proposing designs to a non-engineer product owner who is deeply involved, defending them in writing, and being overruled on product grounds without sulking
• Strong written English; async-first habits; you leave a paper trail by default
• Bonus, not required: search infrastructure (Typesense/similar), data-pipeline/ETL work, having worked alongside scraper/ingestion systems, PostgreSQL depth

This is for our product Booking Agent Info (BookingAgentInfo.com)

This isn't a standard WordPress role. We're looking for someone with deep technical ability who can work across databases, write and integrate APIs, and build advanced custom solutions — not just configure templates and plugins.
 

We move fast and care about hitting real product milestones. That means the work has intensity: sprints where you're heads-down solving hard problems, and moments where extra effort makes the difference between shipping on time and slipping. 

We're looking for someone who brings genuine drive and ownership to that, not someone clocking in and out. We want sustainable intensity from people who care about what they're building.
 

If you take initiative without being asked, think beyond the ticket in front of you, and want to help shape a product rather than just execute tasks, this could be a great fit.

What You'll Do:

• Design and build custom WordPress functionality beyond standard themes/plugins (custom post types, advanced ACF/Gutenberg blocks, plugin architecture)
• Write and integrate REST/GraphQL APIs connecting WordPress to internal tools and third-party services
• Manage and optimize large, complex databases for performance and scale
• Own features end-to-end: scoping, building, testing, and shipping
• Identify technical debt or UX friction and propose solutions proactively
• Maintain and extend multilingual site infrastructure (Polylang/WPML)
   

What We're Looking For

• Deep PHP/WordPress expertise — comfortable well beyond theme/plugin basics; experience building and scaling complex platforms
• API development — building and integrating APIs from scratch, not just consuming third-party plugins
• Database fluency — managing, querying, and optimizing large databases
• Multilingual site experience — hands-on with Polylang or WPML
• Ownership mindset — you test your own work, troubleshoot edge cases, and follow through without being chased
• Product sense — you think about user experience and business impact, not just code correctness

• 5+ years building production WordPress applications