You are viewing a preview of this job. Log in or register to view more details about this job.

Tech Lead, Full Stack Mobile Engineer (Go, React Native — iOS)

We b0nd
Email

Tech Lead, Full Stack Mobile Engineer (Go, React Native — iOS)

Overview

We’re hiring one hands-on Tech Lead to own end-to-end engineering execution for an iOS-first React Native app and a Go backend.
 

You will be the primary technical owner: the person who understands the whole system, drives implementation decisions, keeps quality high, and ensures delivery. You will not be doing product management or UI design—those are owned by others—but you will lead development and be accountable for engineering outcomes.


 

Stage: The project is near MVP and already in progress. This role is about taking over the existing codebase, establishing a clear direction, and driving it through MVP completion and beyond.


 

About We b0nd: A digital members’ club built on trust, where new connections are made through your existing network. 

 

What you’ll do

Lead delivery and technical execution

  • Take ownership of the current MVP codebase and drive it to completion.
  • Define and maintain system boundaries: mobile/app architecture, backend architecture, data model, and API contracts.
  • Plan milestones with the PM, make scope tradeoffs, and ship consistently.
  • Set engineering standards: code quality, reviews, testing strategy, release discipline, and operational readiness.

Build and evolve the product stack

  • Build and maintain backend APIs and services in Go (REST).
  • Design and evolve PostgreSQL schemas and queries (migrations, indexing, performance tuning).
  • Implement Redis caching where it improves performance and cost.
  • Build event-driven workflows (e.g., Kafka producers/consumers) where appropriate.

Own mobile delivery (iOS-first)

  • Build React Native features in TypeScript with a strong iOS shipping mindset.
  • Own iOS release operations: signing, provisioning, TestFlight, App Store submissions.
  • Debug production issues across JS and native layers when needed.

Operate production systems

  • Containerization (Docker), deployments (Kubernetes/GKE), infrastructure-as-code (Terraform or equivalent), and CI/CD (e.g., GitHub Actions).
  • Incident troubleshooting and reliability improvements: observability, safe rollouts, and pragmatic operational practices.

Performance-first engineering expectations

This product is being built to handle heavy usage from the start. We’re aiming for MVP that is fast, stable, and ready to scale.

What success looks like

  • You take over the existing codebase and quickly establish clarity: what’s solid, what’s risky, what needs to change.
  • MVP completes and ships with a predictable cadence.
  • Backend changes are safe, observable, and easy to troubleshoot.
  • Mobile releases become routine and deadlines are met.
  • The rest of the engineering team becomes more effective because the system has standards and clear ownership.

Requirements (must-have)

You can do everything listed below in a real production setting—not just in theory:
 

  • Proven experience being the end-to-end owner of a production system (lead/staff/senior owner equivalent).
  • Strong backend experience building and operating APIs/services in Go.
  • Strong SQL and hands-on PostgreSQL experience (schema design, migrations, performance tuning).
  • Experience with event-driven systems (e.g., Kafka) and distributed-service fundamentals.
  • Experience applying practical caching strategies (e.g., Redis) in production.
  • Professional React Native (TypeScript) experience shipping production apps.
  • iOS release ownership: signing, TestFlight, App Store submissions.
  • Experience running production workloads with Docker and Kubernetes in a cloud environment (GCP preferred; equivalent is fine).
  • Infrastructure-as-code (e.g., Terraform) and ownership of CI/CD workflows (e.g., GitHub Actions).
  • Strong engineering habits: code review discipline, testing where it matters, and clear written communication.
  • Experience with authentication/OTP flows and secure session handling.

Nice-to-have (not required)

  • Experience with common Go web frameworks (e.g., Gin, Echo, Chi, Fiber).
  • Deep Kubernetes/GKE operational experience (deployments, debugging, rollout strategy).
  • Experience designing reliable async pipelines (consumer retries, DLQs, message contracts).
  • Some native iOS knowledge (Swift/Objective-C) for debugging/bridging.
  • Prior experience leading a small team or acting as the technical “closer” on a product.

Notes on role shape

  • This is a hands-on role. You will write code across mobile, backend, and infrastructure.
  • You are the technical owner and the primary point of accountability for engineering execution.

Product management and UI/UX design are handled by others; you partner closely with them, but you lead development.