Sayef Khan

Software Engineer

Specialising in multithreaded systemsModular code

About

Hello,

I’m Sayef, an engineer who builds software that stays fast & modular as the team grows. I enjoy the behind-the-scenes details that keep everything running smoothly: queue semantics, module boundaries, the migration plan nobody wrote down.

Three years across backend platforms, product frontends and the seams between them. I leave behind code that the next person can change without asking me first.

Past projects

04 projects

Code

beacon/api.py

1# beacon/api.py: grounded answers, streamed with sources
2@app.post("/ask")
3async def ask(q: Question, user: User = Depends(auth)):
4    hits = await search(q.text, team=user.team, k=6)
5    if not hits:
6        return {"answer": None, "reason": "no matching docs"}
7
8    prompt = build_prompt(q.text, hits)
9
10    async def stream():
11        async with client.messages.stream(
12            model=MODEL,
13            max_tokens=800,
14            system=SYSTEM_PROMPT,
15            messages=[{"role": "user", "content": prompt}],
16        ) as s:
17            async for text in s.text_stream:
18                yield text
19        yield cite(hits)
20
21    return StreamingResponse(stream(), media_type="text/plain")
22
23
24async def search(text: str, team: str, k: int) -> list[Doc]:
25    vec = await embed(text)
26    return await db.fetch(
27        "SELECT * FROM docs WHERE team = $1 "
28        "ORDER BY embedding <=> $2 LIMIT $3",
29        team, vec, k,
30    )

Product

beacon grounded

How do I order a new laptop for a starter?

Raise a hardware request in the IT portal at least 10 working days before the start date¹. Managers approve it, then Procurement ships to the office or home address on file².

1 IT Handbook · p.12
2 Procurement policy · §3.2

Ask anything about how we work…

012023

Beacon

AI knowledge assistant

An internal assistant that answers staff questions from 40,000 company documents and shows the exact page each answer came from.

Internal “how do I” support tickets fell by 38% in its first quarter.

Python
FastAPI
pgvector
Claude API

Code

payouts/router.ts

1// modules/payouts/router.ts
2export const payoutsRouter = router({
3  list: protectedProcedure
4    .input(z.object({ status: PayoutStatus }))
5    .query(({ ctx, input }) =>
6      ctx.db.payout.findMany({
7        where: { status: input.status },
8        orderBy: { createdAt: "desc" },
9        take: 50,
10      }),
11    ),
12
13  approve: withRiskCheck(protectedProcedure)
14    .input(z.object({ id: z.string() }))
15    .mutation(async ({ ctx, input }) => {
16      await ctx.audit("payout.approve", input.id);
17      return ctx.payouts.approve(input.id);
18    }),
19});
20
21// apps/console/modules.ts
22export const modules = [risk, payouts, support];

Product

PayoutsApprove

Northwind Ltdpo_8f21£12,480.00pending
Acme Freightpo_8f1c£3,915.20review
Kite & Copo_8f0a£842.00paid
Blue Harbourpo_8ef7£27,100.00paid
Lumen Studiopo_8ee3£1,260.75paid

[email protected] · deployed 14 min ago

022024

Ledgerline

Modular payments console

An operator console split into independently deployable modules, so the risk, payouts and support teams ship on their own schedule.

Release cadence moved from fortnightly to 11 deploys a week.

Next.js
TypeScript
tRPC

Code

relay/worker.go

1// worker.go: steal from peers when idle
2func (w *Worker) Run(ctx context.Context) {
3  for ctx.Err() == nil {
4    job, ok := w.local.Pop()
5    if !ok {
6      job, ok = w.steal(ctx)
7    }
8    if !ok {
9      w.park(ctx, 50*time.Millisecond)
10      continue
11    }
12    w.exec(ctx, job)
13  }
14}
15
16func (w *Worker) steal(ctx context.Context) (Job, bool) {
17  res, _, err := w.rdb.XAutoClaim(ctx,
18    &redis.XAutoClaimArgs{
19      Stream: "relay:jobs", Group: "workers",
20      Consumer: w.id, MinIdle: 2 * time.Second,
21      Start: "0-0", Count: 1,
22    }).Result()
23  if err != nil || len(res) == 0 {
24    return Job{}, false
25  }
26  return decode(res[0]), true
27}

Product

relay prod

p95 queue latency240 msfrom 1.8 s

throughput12.4k/s

work-stealing workers

032025

Relay

Concurrent job runtime

A work-stealing scheduler for a logistics platform, replacing a single-queue worker pool that stalled under burst traffic.

p95 queue latency went from 1.8 s to 240 ms at the same hardware cost.

Go
Postgres
Redis Streams

Code

sync/merge.rs

1// sync/merge.rs: conflict-free on reconnect
2impl Note {
3    pub fn merge(&mut self, remote: &Note) {
4        for (id, op) in &remote.ops {
5            self.ops.entry(*id).or_insert(op.clone());
6        }
7        self.clock.join(&remote.clock);
8        self.body = self.ops.render();
9    }
10
11    pub fn persist(&self, db: &Connection) -> Result<()> {
12        let tx = db.unchecked_transaction()?;
13        for op in self.ops.since(self.synced_at) {
14            tx.execute(
15                "INSERT OR IGNORE INTO ops VALUES (?1, ?2)",
16                params![op.id, op.to_bytes()],
17            )?;
18        }
19        tx.commit()
20    }
21}

Product

Field notes synced

Transect B, plot 4Lichen cover up ~20% since…
Water sample logpH 6.8, turbidity low, 2 vials
Bird count, ridge3× ptarmigan, 1× raven
Camp inventoryFuel for 4 more days

Back online after 3 days · 41 edits merged, 0 conflicts

042026

Fieldnote

Offline-first sync engine

CRDT-based note sync for field researchers working without signal for days at a time, with conflict-free merges on reconnect.

Zero data-loss reports across 14 months in production.

Rust
SQLite
React Native

Services

Drag or scroll sideways

What I bring to a team

export function useCart(userId: string) {
  const [items, setItems] = useState<Item[]>([]);
  useEffect(() => {
    fetch(`/api/cart/${userId}`)
      .then((r) => r.json())
      .then(setItems);
  }, [userId]);
  const total = items.reduce((s, i) => s + i.price, 0);
  return { items, total, add: (i: Item) => setItems([...items, i]) };
}

app.post("/api/cart/:id", requireAuth, async (req, res) => {
  const cart = await Cart.findOrCreate(req.params.id);
  cart.add(req.body.item);
  res.status(201).json(await cart.save());
});

01.tsx

Full-stack development

End-to-end features, from the screen a user taps to the server and database behind it.

Frontend

React
Next.js
TypeScript
HTML & CSS
Tailwind

Backend

Node.js
Express
REST APIs
GraphQL
Auth

#include <pthread.h>
#include <stdlib.h>

typedef struct node { int val; struct node *next; } node_t;

static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void push(node_t **head, int val) {
    node_t *n = malloc(sizeof(node_t));
    n->val = val;
    pthread_mutex_lock(&lock);
    n->next = *head;
    *head = n;
    pthread_mutex_unlock(&lock);
}

int sum(const node_t *head) {
    int total = 0;
    for (; head; head = head->next) total += head->val;
    return total;
}

02.c

Languages

Comfortable moving between languages and picking the right one for the job.

Python
JavaScript
TypeScript
Java
C
C++
C#
Go
SQL
Bash

#!/usr/bin/env bash
set -euo pipefail

branch="feature/${1:?usage: ship <name>}"
git checkout -b "$branch"
npm ci && npm test

docker build -t app:"$(git rev-parse --short HEAD)" .
docker compose up -d db cache

for f in migrations/*.sql; do
  psql "$DATABASE_URL" -f "$f"
done

git push -u origin "$branch"
gh pr create --fill --draft

03.bash

Tools & workflow

The everyday kit teams expect you to know on day one.

Git & GitHub
VS Code
Docker
Linux
Postman
npm
Jira
Figma

func healthHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
		defer cancel()
		if err := db.PingContext(ctx); err != nil {
			http.Error(w, "db unavailable", 503)
			return
		}
		w.WriteHeader(http.StatusOK)
	}
}

func main() {
	mux := http.NewServeMux()
	mux.Handle("/healthz", healthHandler(openDB()))
	log.Fatal(http.ListenAndServe(":8080", mux))
}

04.go

Cloud & DevOps

Shipping code safely and keeping it running once it is live.

Azure
AWS
CI/CD
GitHub Actions
Kubernetes
Terraform
Monitoring

CREATE TABLE orders (
  id          BIGSERIAL PRIMARY KEY,
  customer_id BIGINT NOT NULL REFERENCES customers(id),
  status      TEXT   NOT NULL DEFAULT 'pending',
  total_cents INTEGER NOT NULL CHECK (total_cents >= 0),
  created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE INDEX orders_customer_idx ON orders (customer_id, created_at DESC);

SELECT c.name, COUNT(o.id) AS orders, SUM(o.total_cents) / 100.0 AS spend
FROM customers c
JOIN orders o ON o.customer_id = c.id
WHERE o.created_at > now() - interval '30 days'
GROUP BY c.name
ORDER BY spend DESC
LIMIT 10;

05.sql

Databases & data

Designing how data is stored so it stays correct and fast to query.

PostgreSQL
MySQL
MongoDB
Redis
Prisma
Data modelling

def answer(question: str, k: int = 4) -> str:
    query = embed(question)
    docs = index.search(query, top_k=k)
    context = "\n\n".join(d.text for d in docs)
    reply = client.messages.create(
        model=MODEL,
        max_tokens=512,
        messages=[{"role": "user", "content": f"{context}\n\nQ: {question}"}],
    )
    return reply.content[0].text


def chunk(text: str, size: int = 800, overlap: int = 100):
    for start in range(0, len(text), size - overlap):
        yield text[start : start + size]

06.python

AI & machine learning

Building features on top of modern AI models, not just using them.

LLM APIs
RAG
Prompt design
PyTorch
pandas
Vector search

class InvoiceServiceTest {

    private final Clock clock = Clock.fixed(Instant.parse("2025-01-01T00:00:00Z"), UTC);
    private final InvoiceService service = new InvoiceService(new InMemoryRepo(), clock);

    @Test
    void appliesLateFeeAfterThirtyDays() {
        Invoice inv = service.create(new BigDecimal("100.00"));
        service.advance(Duration.ofDays(31));

        assertEquals(new BigDecimal("105.00"), service.balance(inv.id()));
    }

    @Test
    void rejectsNegativeAmounts() {
        assertThrows(IllegalArgumentException.class,
            () -> service.create(new BigDecimal("-1")));
    }
}

07.java

Testing & quality

Code that is reviewed, tested and safe for the next person to change.

Unit tests
Jest
PyTest
JUnit
Playwright
Code review
TDD

template <typename T>
class BoundedQueue {
public:
    explicit BoundedQueue(size_t cap) : cap_(cap) {}

    void push(T item) {
        std::unique_lock lock(m_);
        not_full_.wait(lock, [&] { return q_.size() < cap_; });
        q_.push(std::move(item));
        not_empty_.notify_one();
    }

    T pop() {
        std::unique_lock lock(m_);
        not_empty_.wait(lock, [&] { return !q_.empty(); });
        T item = std::move(q_.front());
        q_.pop();
        not_full_.notify_one();
        return item;
    }

private:
    std::queue<T> q_;
    std::mutex m_;
    std::condition_variable not_full_, not_empty_;
    size_t cap_;
};

08.cpp

Systems & problem solving

The fundamentals interviews test and real systems depend on.

Data structures
Algorithms
System design
Multithreading
Networking
OOP

Contact

Got a project in mind? Let’s talk it through.

[email protected]

Open to full-time roles and select contracts