beja-hash beja-hash
TypeScript
Python
JavaScript
API Design: 5/10
Data Layer & Database: 5/10
Scalability & Performance: 5/10
Active 17 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A senior-level automation engineer focused on resilient browser automation and worker orchestration, with clear ownership of a complex Playwright-based runtime. The strongest proven skill is building robust browser runtime orchestration and recovery logic, evidenced by BoostCard/backend/app/worker/tasks.py (ProfileRuntimeManager, cdp launch semaphore, watchdogs and detailed diagnostics). Public code lacks dedicated test-infra patterns like contract testing or load-test harnesses and there are limited CI/flake-engineering artifacts visible.
Technical skills
TypeScript• Senior
Python• Senior
JavaScript• Senior
Python
FastAPI
Alembic
Celery
Beautiful Soup
HTTPX
SQLAlchemy
Pydantic
Databases
PostgreSQL
Redis
RediSearch
Apache Kafka
DevOps
AWS Lambda
Docker Compose
QA
Playwright
Pytest
Senior Backend Developer
Confidence: High API Engineer
A backend API engineer at a senior level who builds production web services integrating crawling, analysis and LLM-driven fixes. The strongest proven skill is architecting an AI-fix pipeline (parsing, grouping, LLM prompt/context construction and patch application) as evidenced by app/services/ai_fix/* modules and related routes in app/api/routes/ai_fix.py and app/api/routes/fixes.py. Public code lacks explicit platform-wide SLO/alerting configs, advanced DB transaction/isolation tuning traces, and multi-service contract/versioning artifacts.
API Design
5/10
How well APIs are designed
API design shows deliberate choices: consistent error contract builder, Idempotency-Key handling, per-endpoint rate limiting, and structured response models. Some best-practices (versioning strategy, formal pagination conventions) are not prominent or are conventional rather than advanced.
Evidence
beja-hash/seogeo/backend/app/api/routes/fixes.py: handling of Idempotency-Key header and `_generate_for_issue` idempotency checks
beja-hash/seogeo/backend/app/api/routes/ai_fix.py:_build_error_response and consistent JSON error payloads with trace_id
beja-hash/seogeo/backend/app/api/routes/fixes.py:_rate_limit_or_raise use of Redis for per-user/per-endpoint rate limiting
Data Layer & Database
5/10
Working with databases
Data layer shows migration history, declarative models, and deliberate crud abstractions using async SQLAlchemy. Transaction and isolation-level decisions are implicit (SQLAlchemy async sessions used) but explicit complex transaction handling or advanced tuning is not visible in the sampled code.
Scalability & Performance
5/10
Handling load and speed
Scalability work is present: asynchronous HTTP fetching with retries/backoff, Redis-backed rate limits and Celery/worker decoupling. There are no visible advanced benchmarking artifacts or cache invalidation strategies beyond standard patterns.
Evidence
beja-hash/seogeo/backend/app/services/ai_fix/pipeline.py: fetch_html with retries and exponential backoff
beja-hash/seogeo/backend/app/api/routes/fixes.py: per-user rate limits via Redis in `_rate_limit_or_raise` and generation quota checks
beja-hash/seogeo/backend/app/workers/tasks.py and beja-hash/seogeo/backend/app/workers/celery_app.py: Celery worker task usage and background audit processing
System Architecture
5/10
Overall system structure
Clear modular service decomposition (api routes, ai_fix service, pipeline, patch_engine, session_engine, crawler) and worker separation. Service boundaries are sensible for a single product; there is no evidence of a distributed multi-service contract design beyond worker/queue separation.
Evidence
beja-hash/seogeo/backend/app/services/ai_fix/* - distinct modules (pipeline, llm, patch_engine, session_engine) separating responsibilities
beja-hash/seogeo/backend/app/api/routes/* - routers separated by domain (ai-fix, fixes, geo, audits) and main app mounting in app/main.py
beja-hash/seogeo/backend/app/workers/tasks.py - background worker / crawler orchestration separated from HTTP API
Security & Auth
5/10
Protecting data and access
Security-conscious patterns are visible: password hashing, JWT usage, refresh token patterns in utils, pydantic input validation, and scoped DB session usage. Advanced automated dependency-audit artifacts or explicit SSF/SSRF mitigations are not visible in samples beyond URL validation and sanitized fetches.
Evidence
beja-hash/seogeo/backend/app/utils/auth.py - functions for hash_password, verify_password, create_access_token, create_refresh_token, decode_token
beja-hash/seogeo/backend/app/api/deps.py:get_current_user dependency (auth boundary)
beja-hash/seogeo/backend/app/schemas/* - pydantic schemas used for request validation (e.g., app/schemas/ai_fix.py)
Reliability & Observability
5/10
Stability and monitoring
Good observability and reliability practices: structured logging with trace ids, retry/backoff for external calls, and tests that assert task failure handling. Missing are system-level circuit breakers, full graceful shutdown patterns, or observable SLIs/alerting configs in sampled files.
Evidence
beja-hash/seogeo/backend/app/api/routes/ai_fix.py - trace_id generation and extensive structured logging around stages
beja-hash/seogeo/backend/app/services/ai_fix/pipeline.py: fetch_html with retry/backoff and exception handling
beja-hash/seogeo/backend/tests/test_celery_task_status.py and other tests - unit tests covering failure modes and task status behaviors
Expertise
Backend AI & LLM• Senior
Python• Senior
Microservices & API Architecture• Senior
Messaging & Real-time• Senior
Industries
Sales & Marketing• Middle
Technologies
PostgreSQL
Redis
Apache Kafka
RediSearch
AWS Lambda
Recommendations
- Lead development of API-first features that integrate LLM prompts with deterministic input normalization - own prompt/context engineering and idempotent generation flows.
- Build and harden background processing at scale - design worker autoscaling, rate-limiting policies, and queue backpressure strategies for Celery/Redis.
- Implement end-to-end observability and SLOs - add Prometheus metrics, dashboards, and alert rules tied to generation latencies and error budgets.
- Drive database migration hygiene and transactional patterns - add explicit migration evolution tests and document transaction/isolation decisions for critical flows.
Senior DevOps Engineer
Confidence: Medium Generalist
A backend-focused generalist at a lower-senior level who designs and implements production web services and AI-driven content pipelines. The strongest proven skill is building reliable asynchronous web systems - evidenced by FastAPI route modules (app/api/routes/ai_fix.py and app/api/routes/fixes.py), Celery worker orchestration and retry/idempotency logic (fetch_html backoff, idempotency checks, and tests around task failure). The public code lacks CI/CD pipelines, cloud-native orchestration manifests (Kubernetes), and explicit secrets or cloud identity integrations.
CI/CD Pipelines
1/10
Automated build and deploy
Minimal CI/CD evidence - repository contains Dockerfiles and docker-compose for local/developer deployment but no reusable CI pipelines, caching/matrix strategies, gated deploys or artifact signing were found.
Evidence
seogeo/backend/docker-compose.yml: service api/worker definitions and healthcheck-driven depends_on
seogeo/backend/Dockerfile: application image build (no CI pipeline files present)
Infrastructure as Code
2/10
Managing servers with code
Basic infrastructure-as-code: docker-compose and Alembic migrations present, but no remote state, locking, environment-separated terraform/pulumi, nor infra tests or state migrations were found.
Evidence
seogeo/backend/docker-compose.yml: postgres and redis services, volumes: pgdata
seogeo/backend/alembic/versions/0001_initial.py: alembic migration files exist
Containerization & Orchestration
4/10
Working with containers
Solid containerization and process orchestration for a service-oriented app - multiple Dockerfiles, docker-compose worker processes, and explicit Celery worker commands with concurrency; missing Kubernetes manifests, resource requests/limits, probes, non-root user hardening and production orchestration settings.
Evidence
seogeo/backend/Dockerfile: python image, entrypoint, EXPOSE 8000
seogeo/backend/docker-compose.yml: api/worker/worker_headless services with Celery command lines and concurrency flags
Observability & Monitoring
4/10
Watching system health
Good observability-in-code: extensive structured logging and health endpoints plus docker-compose healthchecks; however there are no dashboards-as-code, alerting/SLO rules, or tracing/metrics instrumentation visible.
Evidence
seogeo/backend/app/core/logging.py: setup_logging function and usage
seogeo/backend/app/api/routes/ai_fix.py: many logger.info/error calls and structured trace_id handling
Reliability & Incident Response
5/10
Keeping systems up
Strong reliability focus for an application: idempotency keys, rate limits, retry/backoff on fetches, validation and service-level guards; test coverage includes task failure and parser edge-cases, indicating attention to incident scenarios and recoverability.
Evidence
seogeo/backend/app/api/routes/generate/regenerate and seogeo/backend/app/api/routes/ai_fix.py: idempotency key checks and unique-create patterns
seogeo/backend/app/services/ai_fix/pipeline.py: fetch_html with retries/backoff and parser validation errors
seogeo/backend/tests/test_celery_task_status.py: tests that verify run_audit_task failure sets failed status
Cloud & Cost Optimization
2/10
Smart use of the cloud
Some operational/cost-awareness (per-plan quotas, generation rate-limits) are present, but there is no evidence of autoscaling, spot/eviction strategies, rightsizing, workload identity or cloud cost controls.
Evidence
seogeo/backend/app/api/routes/ai_fix.py: _monthly_quota_for_plan and _check_monthly_quota_or_raise
seogeo/backend/docker-compose.yml: local service definitions (no cloud autoscaling present)
Expertise
Site Reliability Engineering• Middle
Observability & Monitoring• Middle
Industries
Internet Services• Middle
Software• Middle
Technologies
Docker Compose
Beautiful Soup
Celery
Recommendations
- Use the developer to implement and extend backend services for AI-assisted content tooling - building FastAPI endpoints, Celery flows and robust parsing/pipeline code (e.g., extend app/api/routes and app/services modules).
- Assign them to harden runtime and platform reliability - add structured metrics, tracing (OpenTelemetry), alerting/SLOs and automated chaos tests around Celery tasks and parsing pipelines.
- Have them evolve deployment and infra-as-code - migrate docker-compose workloads to reproducible CI pipelines and Kubernetes manifests with resource requests, liveness/readiness probes and rollout strategies.
- Engage them to write infra tests and production-grade migrations - implement alembic state migrations, automated DB migrations in CI, and integration tests for end-to-end snapshot/generation flows.
Senior QA Engineer
Confidence: Medium Automation Engineer
A senior-level automation engineer focused on resilient browser automation and worker orchestration, with clear ownership of a complex Playwright-based runtime. The strongest proven skill is building robust browser runtime orchestration and recovery logic, evidenced by BoostCard/backend/app/worker/tasks.py (ProfileRuntimeManager, cdp launch semaphore, watchdogs and detailed diagnostics). Public code lacks dedicated test-infra patterns like contract testing or load-test harnesses and there are limited CI/flake-engineering artifacts visible.
Test Automation Frameworks
2/10
Building automated tests
Light test artifacts exist (unit tests) but there is no dedicated test framework, fixtures, factories or robust test infra visible; most Playwright usage is application automation, not a reusable test harness.
Evidence
BoostCard/backend/tests/test_auth_routes.py: unit tests for auth route behavior
BoostCard/backend/tests/test_grouped_runs.py: scenario and run-status unit tests
Test Coverage & Strategy
3/10
What and how to test
Some negative-path and boundary behavior is tested (scenario ordering, run status), but broad risk-based tagging, property-based tests, mutation testing or explicit flake-engineering artifacts are not present.
Evidence
BoostCard/backend/tests/test_grouped_runs.py: tests like test_empty_group_is_cancelled and test_any_error_marks_completed_group_as_error
API & Integration Testing
3/10
Testing how parts work together
API and integration logic is exercised and there are diagnostic scripts; however there is no evidence of contract testing (pact/schemathesis), schema-driven tests or testcontainers-based integration environments.
Evidence
BoostCard/backend/app/services/gologin_service.py: httpx usage and integration token handling
BoostCard/backend/scripts/gologin_403_diagnostic.py: diagnostic script for integration failure modes
Performance & Load Testing
1/10
Testing speed under load
Operational observability and resource sampling are present inside the worker for runtime health, but no explicit load/performance test harness, SLO checks, or parameterized load scenarios are present.
Evidence
BoostCard/backend/app/worker/tasks.py: _ProfileResourceMonitor sampling and _log_browser_runtime_diagnostics logging
Bug Reporting & Analysis
2/10
Finding and describing bugs
Good diagnostic and logging discipline is visible (detailed watchdog logs, diagnostic capture scripts), but there are no public reproducible bug reports or linked issue fixes shown here.
Evidence
BoostCard/backend/scripts/gologin_403_diagnostic.py: targeted diagnostic tooling for 403 issues
BoostCard/backend/app/worker/tasks.py: detailed _log_step_watchdog_timeout and _log_browser_runtime_diagnostics
CI Test Integration
1/10
Running tests automatically
There are hints of CI/automation (package scripts and at least one workflow file), but no evidence of a mature CI test matrix, selective test runs, per-test quarantine or artifact retention policies.
Evidence
FlowPost/.github/workflows/build-agent.yml: CI workflow file (present but not richly parameterized)
BoostCard/frontend/package.json: test and typecheck scripts
Expertise
SDET & Test Engineering• Middle
Unit & Component Testing• Middle
API Testing & Contract Validation• Middle
Industries
Commerce• Senior
Media & Entertainment• Middle
Technologies
Python• Senior
JavaScript• Senior
TypeScript• Senior
Playwright
SQLAlchemy
FastAPI
Pytest
Pydantic
HTTPX
Alembic
Recommendations
- Use the developer to build resilient browser automation runtimes and workers that require robust recovery policies and diagnostics (Playwright-based runtime orchestration).
- Assign them to implement E2E automation suites and flake-engineering (replace brittle waits with heartbeats/bounded-await patterns and per-test retries).
- Have them design and harden integration tests for API-to-runtime interactions (token handling, idempotency, and error-path simulations using stable mocks or testcontainers).
- Engage them to add observability and SLO-driven alerts for automation runtimes (resource sampling, percentile latencies, and automated artifact capture on failures).