4GOO

The Role

You'll be the engineer who owns the infrastructure platform end to end. That means you're not executing a ticket queue — you're deciding how things should be built, calling out what needs to change, and making it happen. We're at a critical point: the foundations are in place and we need someone who can assess where we are, close the gaps, and get the platform ready for production traffic at scale.

You'll work directly with the architect and development team, so you need to be comfortable making technical decisions, defending them, and explaining trade-offs clearly.

What You'll Work On

- Kubernetes infrastructure across multiple clusters and environments — day-to-day operations, reliability, capacity, and scaling
- CI/CD pipelines — build, test, and deploy flows for a polyglot microservices backend (Go, PHP) and Nuxt.js frontend
- Infrastructure as Code — Terraform-managed AWS resources; you'll improve what's there and introduce what's missing
- Observability — metrics, logs, tracing, alerting; making sure on-call means something actionable, not noise
- Production readiness — identifying and closing the gap between "works in dev" and "handles real load safely"
- Security and access control — IAM, RBAC, secrets management, least-privilege everywhere
- Database and cache operations — PostgreSQL, Redis, and Cassandra in a managed/cloud context
- Disaster recovery and backup — designing and testing runbooks, not just writing them

What We're Looking For

Must have:
- 3+ years operating Kubernetes in production (not just deploying to it — owning it)
- Strong Terraform skills — you write modules, manage state, review others' code
- AWS experience across compute, networking, storage, and IAM
- GitOps mindset — you've used ArgoCD, Flux, or similar and understand why it matters
- Monitoring and alerting experience with the Prometheus/Grafana stack
- Comfortable with Linux, shell scripting, and diagnosing things without a UI
- Able to read and reason about Go, Python, or similar — you don't need to write application code but you need to understand what it's doing

Strong plus:
- Experience with social or media platforms — you've seen what high fan-out writes, real-time messaging, and image/video delivery look like at scale
- Bare-metal or self-hosted experience — understanding what cloud abstractions are hiding is a real advantage
- Familiarity with Karpenter, KEDA, or similar autoscaling tooling
- Experience with Cassandra or other wide-column stores in production
- Security mindset — threat modeling, pen test familiarity, or cloud security certifications

What Good Looks Like in This Role

You join, spend a few weeks understanding the stack, then come back with a clear-eyed view: here's what's solid, here's what's a risk, here's the order we should fix it. You can have that conversation with the architect as a peer, not as someone waiting for direction.

Six months in, the team trusts the platform. Deploys are boring. Incidents have runbooks. Production is not a scary word.

Stack (without the full picture)

Kubernetes · Terraform · AWS · GitLab CI · ArgoCD · Helm · Prometheus · Grafana · Loki · PostgreSQL · Redis · Cassandra · Go microservices

What We Offer

- Meaningful ownership — this isn't a support role inside a 200-person infra team
- Direct access to decision-makers — no layers between you and the people setting direction
- Remote-friendly, async-first culture
- Competitive compensation based on experience

We're building a social networking platform from the ground up — feed, posts, reels, stories, comments, reactions, chats, calls, livestreams, marketplace. We're looking for backend engineers to take ownership of significant parts of the system.

 

What you'll work on

Concrete things on the next 12 months of the roadmap:

- Feed generation, distribution, and the recommendation engine across posts, reels, stories, comments, and reactions: fan-out-on-write vs fan-out-on-read tradeoffs per content type, candidate generation, ranking pipeline (recency, affinity, engagement signals, content-type mixing), cold start, low-latency serving under heavy read load.
- A polymorphic engagement service (likes, comments, mentions, hashtags) across six content types, feeding engagement signals into the ranking pipeline.
- A real-time chat layer: WebSocket gateway with multi-device fan-out, Redis pub/sub event routing, presence and typing indicators.
- Audio/video calls: WebRTC signaling reusing our WS infrastructure, TURN/STUN, peer-to-peer media transport with SFU upgrade path.
- A marketplace service with Stripe Connect (escrow, separate charges, payout scheduling, KYC).
- Livestreams: RTMP ingest, HLS delivery, burst push notifications to follower bases of 100K+, integration with our chat infrastructure.
- CDC pipelines feeding OpenSearch for full-text and geo-search.

 

The stack

- Language: Go.
- Storage: PostgreSQL (relational), Cassandra/Amazon Keyspaces (high-write event logs), Redis (cache, pub/sub, ephemeral state), ClickHouse (analytics), OpenSearch (search).
- Platform: AWS EKS, all services as containers, API gateway.
- Observability: OpenTelemetry → Grafana OSS stack (Loki, Tempo, Mimir) for logs, traces, metrics, and alerting.
- Async: WebSocket, Redis pub/sub, FCM/APNS for push.
- Workflow: Product writes BRDs → we design the OpenAPI/AsyncAPI spec → backend ships a mock service → all teams develop in parallel → swap to real → QA → release. AI-assisted coding is part of how we work, not a side experiment.

 

What we're looking for

- Strong system design instincts. You can read a BRD, sketch the service boundaries, choose the right storage for each access pattern, and explain the tradeoffs. We care about this more than any specific framework.
- No tool tribalism. You pick the simplest thing that solves the problem. You don't reach for Kafka when Redis pub/sub does the job, and you don't reach for Postgres when the workload is append-only events.
- Production Go experience building backend services that are actually live somewhere, and comfort with concurrency primitives.
- Hands-on with at least most of: PostgreSQL, Redis, a wide-column store (Cassandra/Scylla/DynamoDB), an API gateway, containerized deployments on Kubernetes, OpenTelemetry-style observability.
- Independent operator. You don't wait to be told what to do next. You read the spec, identify the unknowns, ask the right questions early, and ship.

 

Bonus

- Feed, timeline, or recommendation systems experience — fan-out architectures, candidate generation, ranking pipelines, ML-served scores in a serving path.
- Real-time systems experience (WebSocket gateways, presence, pub/sub fan-out).
- WebRTC or media-server work.
- Marketplace or payments work (Stripe Connect especially).
- Search infrastructure (OpenSearch / Elasticsearch, CDC pipelines).
- Terraform and infra-as-code comfort.

 

How we work

Small team, flat structure. Two-week sprints. Backend engineers own their services end-to-end: design, build, observe in production, fix. Engineers are expected to read specs, identify unknowns, ask questions early, and ship without being assigned next steps.