Full-time/Part-time · Remote/In-person The role

We're an early-stage team building an AI product on a Python backend. The backend is a FastAPI service over Postgres. The problems that make this job compelling are the ones that come with letting a language model take real actions on real data: ensuring a piece of work happens exactly once, ensuring a person stays in control of anything consequential, and being able to reconstruct exactly what happened and why afterwards.

What you'd work on

● The loop around a model: assembling context within a token budget, validating what comes back, executing the tool calls it asks for, and streaming the result to the client while all of that is still in flight.

● REST API design and implementation against a multi-tenant Postgres database.

● Background job processing. Idempotency, atomic claiming, retries, and correct behaviour when a worker dies halfway through a task.

● Schema design and migrations, with correctness enforced by database constraints rather than defended in application code.

● Retrieval: chunking, embeddings, vector similarity search in Postgres.

● Third-party service integrations: model providers, email, notifications, and file storage.

● Tests that reproduce real concurrency bugs, and tests that hold up when the thing under test is non-deterministic.

You'll be reading and extending an agent runtime that we wrote ourselves. We call model APIs directly rather than through an agent framework, so you need to understand the loop, not a library that hides it.

What we're looking for

● 2–3 years writing Python backends that real users hit.

● You've called a language model API directly. Structured output, tool calling, streaming. A side project counts.



What matters is that you've handled a model's response as data and dealt with it being wrong.

● Genuine SQL. You can explain where a transaction begins and ends, what happens when two workers try to claim the same row.

● Async Python for real. Concurrent I/O, timeouts, cancellation, and what `async` actually buys you when the slowest call in the system is a model that takes twelve seconds to respond.

● You treat model output as untrusted input. Validated at the boundary with Pydantic or equivalent, never passed through on trust.

● You test concurrent code by making it concurrent. Spawning real clients, not mocking the thing that was the point.

● - Docker, git, CI.

● You write things down.** We work across time zones. A decision that exists only in someone's head does not exist.

Helpful, not required

● Multi-tenant data isolation. Postgres row-level security, or any model you've had to defend in practice.

● Evals. Any experience deciding whether a prompt change made things better or worse, and how you'd know.

● Embeddings and vector search. pgvector or otherwise.

● Prompt injection and the other ways a model gets talked into doing something it shouldn't.

● Token usage, latency, and cost as things you've had to measure and bring down.

● Experience being the person who got paged when it broke.

How we work

Architecture decisions get written down before they get built, and the document is the contract. Everything goes through code review. We use AI coding tools extensively and expect you to as well. We also expect you to be able to defend any line you ship, whatever wrote it. Small team, so the scope is broad and there's nobody to hand the hard part to.

Apply

Email [email protected] with your CV and GitHub, and a link to something you've built if you have one.

Attention: Reza

-

📌 Full Stack Developer (Halifax Regional Municipality)
🏢 WorkCore AI
📍 Halifax Regional Municipality