Senior Backend Engineer – Python / FastAPI
Infrastructure Platform Role
About salesXchange
salesXchange is building a structured GTM Operating System for B2B SaaS and technology companies.
The system replaces fragmented digital marketing with deterministic automation across:
- Social visibility (Social444)
- TAM email execution
- Live broadcast infrastructure
- Automated research and proposal generation
- GA4 and BigQuery-driven reporting
The engine already exists. It works.
We are now codifying it into a structured platform layer.
The Role
We are seeking a Senior Backend Engineer to formalise and harden our Python automation engine into a clean FastAPI-based orchestration layer.
This is not greenfield SaaS. This is infrastructure productisation. You will turn working automation into a structured, secure, callable service that supports a React-based Operator Console.
What You Will Do
- Wrap existing Python scripts into structured FastAPI endpoints
- Design and implement a job execution framework (start, monitor, retry, log)
- Structure deterministic state transitions across automation workflows
- Implement secure environment configuration and secrets handling
- Design authentication and role-based access
- Package services using Docker
- Implement structured logging and health-check endpoints
- Document architecture clearly for frontend integration
What We Are Looking For
Required
- Strong Python
- FastAPI (or equivalent API framework experience)
- REST API design
- Environment configuration management (.env, secrets)
- Docker
- Linux/macOS deployment knowledge
- Git workflows
Advantageous
- Background task queues (Celery, RQ, etc.)
- Auth systems (JWT or OAuth basics)
- Experience working with automation pipelines
- Familiarity with API integrations (Notion, ESPs, etc.)
What This Role Is Not
- Not a Kubernetes-heavy DevOps position
- Not microservices theatre
- Not machine learning
- Not consumer SaaS at scale
This is disciplined infrastructure engineering.
Engagement
We are open to:
- Contract engagement (initial build phase)
- Permanent hire
- Hybrid working model
If you are commercially minded and prefer building systems that replace complexity rather than add to it, we would like to speak with you.
Excellence Defined
System Thinking
Excellence means:
- You think in execution flow, not isolated functions
- You design explicit service boundaries
- You avoid hidden side effects
- You structure deterministic state transitions
You understand that automation infrastructure must be predictable before it can scale.
API Design Discipline
Excellence means:
- Clear endpoint design
- Explicit input validation
- Structured error responses
- Idempotent operations where required
- Clean separation between job initiation and job status
You do not build endpoints that “mostly work.”
You build endpoints that behave consistently.
Environment & Configuration Control
Excellence means:
- Secure secrets handling
- Deterministic .env management
- Clear separation of environment-specific configuration
- Zero configuration drift
You understand that environment errors are commercial risks.
Observability & Logging
Excellence means:
- Structured logging
- Clear job status visibility
- Minimal ambiguity in failure states
- Explicit success/failure boundaries
You make debugging boring and predictable.
Deployment Maturity
Excellence means:
- Clean Docker packaging
- Predictable startup behaviour
- Health-check endpoints
- Version-controlled deployment logic
You build systems that can be replicated safely.
Cross-Role Expectations
Regardless of role, excellence includes:
- Writing code that is readable six months later
- Preferring simplicity over cleverness
- Communicating trade-offs clearly
- Respecting defined architecture
- Avoiding unnecessary technology layering
We value engineers who understand that:
Infrastructure must be commercially grounded.
What Excellence Does Not Look Like
- Introducing microservices without need
- Suggesting Kubernetes for small-scale infrastructure
- Adding tools that do not reduce labour
- Overcomplicating simple workflows
- Hiding complexity behind abstraction
We optimise for clarity, not spectacle.
Why This Matters
The sX GTM Operating System is designed to replace fragmented digital marketing stacks.
That requires:
- Precision
- Discipline
- Structured thinking
- Commercial awareness
We are building infrastructure that influences pipeline and revenue.
That demands engineering maturity.
Days 1–30: Architecture Immersion & System Mapping
You will:
- Review full automation flow (Watch → Ingest → Publish → Measure)
- Read script map documentation
- Understand state transitions and folder contracts
- Review environment structure and current .env patterns
- Map existing Python scripts into logical service boundaries
- Identify inconsistencies or risk points
By Day 30:
- You can explain full system flow clearly
- You propose a clean FastAPI service boundary
- You define initial endpoint structure
- You outline job execution abstraction model
No rushed coding.
Clarity first.
Days 31–60: Service Layer Implementation
You will:
- Implement FastAPI skeleton
- Build initial job execution endpoints
- Create structured logging model
- Implement job status retrieval endpoints
- Integrate basic authentication
- Containerise service with Docker
By Day 60:
- Core automation workflows callable via API
- Jobs produce deterministic status outputs
- Health-check endpoints exist
- Service runs cleanly in containerised environment
Manual terminal dependency begins reducing.
Days 61–90: Hardening & Observability
You will:
- Refine error handling
- Improve idempotency where needed
- Add structured failure states
- Finalise logging clarity
- Document API contracts
- Prepare service for frontend integration
By Day 90:
- Backend is stable
- Job execution predictable
- Environment configuration structured
- Ready for full Operator Console integration
Initial conversations only. Send CV and brief introduction to:
No applicant tracking system required at this stage, or agencies.