Senior Software Engineer - Core Platform

Seeka is a first-party customer data platform (CDP) built around high-performance data pipelines that solve attribution and identity in a privacy-constrained world.

We design systems where identity resolution, event ingestion, and routing are architected with user privacy as a foundational principle.

At our core, we are infrastructure - ingesting, resolving, and routing high-volume customer events across platforms with correctness and performance as first principles.

In addition to our core pipeline, we provide advanced dashboards and integration tooling that make identity, attribution, and performance insights directly actionable.

We operate on the bleeding edge of developer experience - internally and for our customers:

Clean SDKs and integration surfaces

Thoughtful APIs

Strong automation and CI/CD

AI-augmented workflows

Carefully designed product interfaces

We care how systems are built just as much as how they run.

The Role We’re hiring a very senior engineer to collaborate on critical systems within Seeka.

This is not a ticket-execution role.

You will:

Design systems with our CTO, not just implement them

Be involved in architectural decisions with long-term impact

Ship new features across backend and product surfaces

Improve performance and reduce systemic complexity

Raise the engineering bar

There is a clear pathway from this role to Lead Developer, working directly under the CTO on architecture, system design, and major technical decisions.

If you are exceptional, this role evolves.

What You’ll Work On Core Platform (C#)

Identity resolution logic

High-throughput ingestion and routing

Business-critical APIs

Integrations & Services (TypeScript)

Seeka integrations

Supporting tooling and automation

Advanced analytics dashboardsAttribution and identity visualisation

Internal operational tools

Infrastructure

Serverless functions

RabbitMQ (experience with MassTransit highly regarded)

Clickhouse

Terraform

GitHub Actions (CI/CD)

You will work across boundaries. Backend-first, but with system-wide control.

What We Expect This is a senior role.

You should:

Have significant experience building and operating production systems

Be strong in TypeScript (backend and frontend)

Be comfortable working across infrastructure and application layers

Have practical experience with:

Terraform

GitHub Actions

You must be able to:

Challenge architectural decisions - including those made by the CTO

Identify flawed assumptions early

Make trade-offs explicit

Improve systems without ego

Work independently with high ownership

Disagreement is welcome. Weak reasoning is not.

AI Fluency We expect you to actively use AI tools to improve how you work.

You should be able to:

Improve code clarity and reduce repetition

Maintain strong engineering judgment while using AI leverage

AI is a force multiplier - not a substitute for thinking.

Experience You have:

Built and operated meaningful production systems

Handled performance bottlenecks and scale

Debugged distributed failures

Rewritten parts of systems when necessary - deliberately

Team Standard We are a small, highly capable engineering team.

We:

Think clearly

Own outcomes

Avoid unnecessary process

Hold a high technical bar

We want to surround ourselves with engineers who are at least as strong as we are - ideally stronger. If you want comfort, this isn’t it.

If you want ownership, architectural influence, and meaningful technical impact - it is.

#J-18808-Ljbffr