Join before it's obvious.

Bring Turkish manufacturers onto the platform and EU buyers across the corridor. You are the first sales hire: you build the pipeline, the playbook and the evidence loop that feeds product. What you sell is specific — a platform where the server refuses a sub-minimum order and bulk production cannot start without an approved sample.

What you'll own

• The supplier early-access pipeline in Türkiye — factory floors and export managers, not just inboxes.
• Buyer-side outreach to EU brands and boutiques sourcing custom production.
• The launch offer: three months free for suppliers, and the founding-supplier prize program.
• A written sales playbook — objections, proof points, honest answers about what is built and what is planned.
• The feedback loop: what factories actually need, filed as evidence, argued into the roadmap.

What we look for

• Native Turkish and fluent English; German or French is a plus.
• You have sold to manufacturers, exporters or B2B operators — and can name what worked.
• You are comfortable on a factory floor and in a procurement call, same day.
• You prefer demonstrating a refusal in the product to promising a feature that is not built.

Stack & context

Territory: Türkiye first, then EU. Base: İstanbul or remote in Türkiye, with travel. Tools: the platform itself, a clean pipeline, and a copy style that bans invented numbers.

Build-in-the-open is our marketing channel — nobody else in this category uses it. You own the cadence: dated updates, real numbers, two languages. The job is making discipline legible, not making noise.

What you'll own

• The /open changelog — dated entries, real counters, an update rhythm that survives busy weeks.
• Bilingual (EN/TR) content: the corridor story, the capability pages, the launch campaign for the September 2026 beta.
• The early-access funnels — supplier, buyer, talent — measured end to end with cookieless analytics.
• SEO on the topics we can win: sourcing from Türkiye, tech packs, AQL inspections, escrow mechanics.
• The claim discipline: every number dated, every status tagged, nothing invented — you enforce it, not just obey it.

What we look for

• You write plainly in English and Turkish — both native-grade, not translated.
• You read funnels and can defend a conclusion with numbers.
• B2B, developer or industrial marketing background — you have sold complicated things to busy people.
• Allergic to hype. Our copy style guide bans the word "revolutionary"; you should find that a relief.

Stack & context

Stack: a static-first Next.js site, Plausible analytics (cookieless), MailerLite, MDX in the repo. Publishing an update is a pull request.

We ran a production iOS marketplace app once already — it lives on the legacy backend today. When this role opens, you retarget it to the new platform in SwiftUI and build Android from zero in Kotlin and Compose, both against the same generated API contract the web uses.

What you'll own

• The iOS retarget: a production SwiftUI app moved onto the new platform, screen by screen.
• Android, greenfield: Kotlin + Jetpack Compose, informed by everything the iOS app taught us.
• Mobile consumption of the 346-operation OpenAPI 3.1 contract — generated clients, no hand-rolled API layers.
• Offline behavior, retry and idempotency on flaky factory-floor networks.
• Both release pipelines, store review to rollout.

What we look for

• You have shipped on both platforms — or deep on one with real work on the other.
• SwiftUI and Compose, not just UIKit and XML memories.
• You treat an API contract as law; client-side workarounds offend you.
• Accessibility and localization on mobile (TR/EN, RTL-ready) are habits, not chores.

Stack & context

Stack: SwiftUI · Kotlin + Jetpack Compose · generated clients from OpenAPI 3.1. Context: mobile is a planned stage after the web platform ships; the existing iOS app is real and runs on the legacy backend.

Our infrastructure plan names its own gaps in writing: alerting not wired, backup cadence unpinned, in-cluster east-west security unowned. You take the estate from specified to production — and close the named gaps, in the open.

What you'll own

• The production cutover to HA k3s on Hetzner ARM — today the local cluster mirrors the specified topology.
• CloudNativePG Postgres operations: backups, restore drills, pinned RPO/RTO.
• The GitOps path: GitHub Actions → GHCR → Argo CD, with CI holding no cluster credentials.
• Alerting, SLOs and burn-rate rules on the Grafana LGTM stack — collection exists; the paging discipline is yours.
• In-cluster security: default-deny NetworkPolicies, mTLS, and the TLS/WAF/CDN decisions currently marked open.

What we look for

• You have run Kubernetes in production and been paged for it.
• Postgres operations: replication, backup verification, the restore you actually tested.
• GitOps conviction — you distrust any pipeline that can kubectl into prod.
• You write runbooks and postmortems without being asked.

Stack & context

Stack: k3s on Hetzner ARM · CloudNativePG · Redis · NATS JetStream · MinIO · Grafana LGTM · Actions → GHCR → Argo CD. Context: the plan's own infra self-assessment is written down gap by gap — that honesty is the job spec.

Ship features end to end: a Go module behind a lint-enforced boundary, a contract-first endpoint, an event on the outbox, a Next.js slice in a token-gated design system. The buyer application is the next big build — you would be early on it.

What you'll own

• Vertical features: schema migration → sqlc queries → service → OpenAPI endpoint → Next.js UI.
• Event consumers on the NATS JetStream backbone — idempotent, deduplicated, DLQ-aware.
• The buyer-app build-out on the shared React Aria + Tailwind token system.
• Tests at near-parity with code — the current ratio is 106,000 test lines to 125,000 production lines; you keep it there.
• Your own ADRs: a boundary change needs a written decision, and you write it.

What we look for

• Strong in Go and TypeScript/React — or strong in one, with proof you cross stacks fast.
• You read the spec first and find that normal.
• Contract-first instincts: the OpenAPI document is the interface, and drift is a build failure.
• You treat accessibility (WCAG 2.2 AA) and i18n (EN/TR/AR, RTL) as part of done — here they gate the merge.

Stack & context

Stack: Go (chi · pgx/v5 · sqlc · goose) · PostgreSQL · NATS JetStream · Typesense · Next.js App Router (RSC-first) · React Aria · Tailwind v4 tokens · 52 merge-blocking CI checks.

The platform holds escrowed money and files that are the customer's intellectual property — the tech pack IS the product. You own the security posture end to end: threat models before features, gates in CI, and the named infrastructure gaps closed.

What you'll own

• The authorization model in practice: default-deny, AND-chained checks, cross-tenant reads answered with 404 — you review every new surface against it.
• The gate walls: govulncheck, SCA, secrets scanning, full-history TruffleHog — extended, tuned, kept failing closed.
• The named gaps: in-cluster east-west security, TLS/WAF/CDN decisions, pod-network encryption.
• The payments plane: webhook signature verification, idempotency, the reconciliation that catches gaps.
• Incident response and a disclosure process, written before the first incident.

What we look for

• Application security plus infrastructure security — you move between a Go diff and a NetworkPolicy.
• You threat-model features at design time and write it down.
• You know why a refresh-token family dies on first reuse — and you would have designed it that way.
• Pragmatic: gates that fail closed without crying wolf.

Stack & context

Context: no RLS — authorization lives in one tested Go package. One byte-enforced rule to defend: an AI check can never be a required merge gate. The deterministic wall is yours.

We already run AI in the loop, honestly: four read-only reviewers, 443 passes, 2,650 findings caught pre-merge — with a build-enforced rule that AI is never the only gate. You take that system further, and you decide, with evidence, where models belong in the product.

What you'll own

• The reviewer system: checklists, templates, and evaluation against the existing findings corpus.
• The injection problem: the repo names prompt injection as a live landmine; hardening it is yours.
• Evals as infrastructure — every AI behavior measured before it ships, monitored after.
• Product proposals: multilingual catalog normalization, RFQ-to-supplier matching — argued in an ADR, gated like everything else.
• The honesty budget: what the models cannot do gets written down too.

What we look for

• You have shipped LLM systems with eval suites, not vibes.
• You can name the failure modes — injection, non-determinism, sycophancy — and design around them.
• Engineering-first: Go, TypeScript or Python in production, not just notebooks.
• You read "AI is never the sole gate" as a feature, not a constraint.

Stack & context

Context: reviewer templates live in the planning repo; deterministic CI is the only merge authority, byte-enforced. As of 2026-08-01: 443 reviewer passes, 2,650 findings, 58 critical — all caught pre-merge.

Design for factory owners and sourcing managers in two languages — three with Arabic — inside a token system where accessibility gates the merge. The buyer experience is the next major surface; you shape it from the first screen.

What you'll own

• Buyer-app flows: search, RFQ, sample approval, order tracking — designed from research, not assumption.
• The design system's evolution: React Aria + Tailwind v4 tokens, every value named, no hardcodes — a lint enforces it.
• The visual-regression matrix: 2,822 approved reference screenshots across 3 widths × light/dark × LTR/RTL — your changes re-baseline it deliberately.
• Code-driven brand art: no stock photography exists on this site, by decision.
• Research with Turkish suppliers and EU buyers — sessions, not surveys.

What we look for

• Systems thinking: you design tokens and components, not just screens.
• Constraints read as protection to you: WCAG 2.2 AA in CI means your contrast decisions survive every future edit.
• You work in EN and TR (Arabic and RTL experience is a real plus).
• You prototype in code — or close enough to hand off without ambiguity.

Stack & context

Stack: React Aria Components · Tailwind v4 CSS-variable tokens · Playwright visual regression at 375/768/1280, light/dark, LTR/RTL. Mobile-first is enforced: a 375px overflow fails the build.