Go Engineer Backend · Remote (worldwide) · Full time View role →

Stat Sniper Inc.; United States; Remote; USD 120,000 - 180,000; Full time

Job summary

Stat Sniper Inc. is hiring a Go backend engineer to own live ingestion services for sports data. You will build high-throughput Go services, containerized on ECS Fargate and Cloud Run, and design a normalization layer to harmonize upstream schemas into a single internal Postgres model.

You’ll use DynamoDB for hot reads and Postgres for relational data, while archiving raw payloads to S3 for safe replay of transforms. You’ll strive for minimal latency and absolute correctness during live games.

Qualifications

• Production Go experience with concurrent systems, including goroutines, channels, context, and backpressure.
• Strong Postgres fundamentals: schema design, indexing, and query performance at scale.
• DynamoDB experience beyond CRUD—access-pattern-first table design, partition keys, and secondary indexes.

Responsibilities

• Build and operate high-throughput ingestion services in Go, running as containers on ECS Fargate and Cloud Run.
• Design the normalization layer that turns multiple upstream provider schemas into one internal model in Postgres.
• Use DynamoDB for hot read paths and Postgres for relational data behind them.
• Archive every raw upstream payload to S3 for replayability of bad transforms.
• Keep latency low and correctness absolute during live games.

Skills

Go concurrency

Postgres fundamentals

DynamoDB design

Containers on AWS/GCP

Observability

Tools

ECS Fargate

Cloud Run

DynamoDB

Postgres

S3

ECR

Pub/Sub

Job description

Own the services that move sports data. Odds, scores, injuries, and lineups arrive from a dozen upstream feeds at different shapes and cadences, and every feature in the product is only as good as that pipeline. You'll build the Go services that ingest, normalize, and fan that data out, and keep them correct while games are live.

What you'll do

• Build and operate high-throughput ingestion services in Go, running as containers on ECS Fargate and Cloud Run.
• Design the normalization layer that turns a dozen upstream provider schemas into one internal model in Postgres.
• Use DynamoDB for the hot read paths that back live scores and odds, and Postgres for everything relational behind them.
• Archive every raw upstream payload to S3 so a bad transform can be replayed instead of re-fetched.
• Keep latency low and correctness absolute during live games, when a stale score is worse than no score.

What we're looking for

• Production Go experience with concurrent systems — goroutines, channels, context, and backpressure.
• Strong Postgres fundamentals: schema design, indexing, and query performance at scale.
• DynamoDB experience beyond CRUD — access-pattern-first table design, partition keys, and secondary indexes.
• Comfort shipping containers to AWS (Fargate, ECR, S3) and GCP (Cloud Run, Pub/Sub) without treating either as magic.
• A bias toward observability: you ship metrics and traces alongside the feature.

Nice to have

• Experience with a provider integration that changed its schema without telling you, and what you did about it.
• Event-driven work on Pub/Sub, Kafka, or Kinesis.
• Sports data domain knowledge — or the appetite to learn how a line actually moves.