Backend and API development in San Francisco
An AI product's backend spends most of its time waiting. A request goes to a model provider and takes seconds, sometimes most of a minute, and meanwhile the user may reload, the provider may rate-limit, and your own API may time out. San Francisco startups often discover this in production, when a backend built for fast database calls starts dropping work under real traffic.
We build backends in Node and Python that treat model calls as jobs rather than requests: queued, retried with backoff, streamed to the client as they progress, and recorded with their inputs, outputs, latency and cost. Provider access sits behind one interface so a second model can take over when the first one fails. The result is a backend where a slow model makes the product slower, not broken.
San Francisco's software market is, for now, largely an AI market. The city is home to the best-known model companies and to a much larger layer of venture-backed startups building products on top of their models, alongside the SaaS, fintech and developer-tool companies that were here before. Most buyers are young companies with funding, a deadline set by their next raise, and more product ideas than engineers.
What they need is rarely the model. It is everything around it: queues for requests that take most of a minute, streaming that survives a dropped connection, fallbacks when a provider is rate-limiting, a record of what each request cost, and evaluation sets that tell you whether last night's prompt change made things better or worse. Then, often within months, the first enterprise customer arrives, and its IT team asks for single sign-on, automatic provisioning, roles their own admin can manage and an activity log they can export. A backend built for a demo meeting that list is where many pilots stall. We build the product and the infrastructure that make a model useful to paying customers, and the enterprise layer that turns a pilot into a contract.
Built In puts the average base salary for a software engineer in San Francisco at around $181,000, and the model companies compete for the same people with equity most startups cannot match. For a seed or Series A company, every senior hire becomes a search measured in months, and the roadmap waits while it runs. The work that piles up in the meantime is usually well defined: a provider integration, an admin console, a move to usage-based billing, a mobile companion app. That is the work we pick up in days and deliver in pieces you can judge on their own.
We work from Bengaluru with four hours of live overlap every working day, placed across your morning in San Francisco. Stand-ups, design calls and code review happen in that window, with the engineer who writes the code. Everything decided outside it goes into your repository, your tracker and the architecture notes we write as we go, so you start each day knowing what moved.
We fit best when the work is defined and the roadmap will not wait for a hire: the product and infrastructure around a model, the enterprise features a first large customer asks for, or the months before your next engineer starts. Most teams begin with a fixed-price two-week piece. Agencies can bring us in white-label, under their own name.
Four ways this arrives.
We read the code, write down what it does versus what everyone believes it does, and give you the list of the five things most likely to page someone at night. Then we fix those first.
Usually queries, not architecture. We profile under real traffic, fix the plans and the indexes, and only then discuss whether anything needs splitting apart.
A mobile client, a partner integration, a public API. We design the contract first, version it properly, and write the docs your consumers will read.
Jobs that silently vanish, retries that duplicate charges, a queue nobody monitors. We make it idempotent, observable, and boring.
A moderated messaging backend where sends acknowledge in-band and the review runs behind them.
Read the write-up →Asked by San Francisco teams.
How do you work with teams in San Francisco?+
We are in Bengaluru and overlap with you for four hours every working day, placed across your San Francisco morning. Stand-ups, design calls and code review happen live in that window, with the engineer who writes the code. We work inside your tools: Slack for conversation, GitHub for code and review, Linear for the plan. Anything decided outside the window is written down there, so nothing depends on memory.
Do you build for AI startups?+
Yes. Most of that work sits around the model rather than inside it: retrieval over your own data, evaluation sets that run on every prompt change, streaming interfaces, cost tracking per customer, fallbacks between providers, and logging that explains an answer after the fact. Then comes the enterprise layer your first large customer asks for: single sign-on, provisioning, admin roles and activity logs, built so the pilot can become a contract.
How does your rate compare to hiring in San Francisco?+
Built In puts the average base salary for a software engineer in San Francisco at about $181,000, before equity and benefits. Our published rate is $35 an hour, with a $5,000 minimum. There is no recruiting search and no employment overhead, and we can start within days. Most teams begin with a fixed-price two-week piece at $2,800, so you judge us on working code before committing to more.
Can you make our prototype ready for real customers?+
Yes, and it is a common place to start here. A prototype built fast for a demo usually needs the same things: model calls moved into queued, retried jobs, costs recorded per request, tests around the parts that change most, and deploys from CI. We read the code, send a written plan within a week, then take the most urgent piece as a fixed-price two-week job. The repository is yours throughout.
Can you work in our existing codebase?+
Yes, and it is most of what we do. We do not require a rewrite as a condition of working with you. If we think a rewrite is genuinely the right call we will say so, with the reasoning and the cost, and you can decide.
What if the backend is in a language you do not list?+
Then we will tell you. We are useful in Node, Python and TypeScript. We can read Go and PHP well enough to migrate off them. We would not take a Rust or Elixir project and learn it on your budget.
Do you write tests?+
For anything with money, permissions or data loss in it, yes. We do not chase a coverage number. We will tell you which parts are covered and which are not in the handover notes.
Who owns the code?+
You do, from the first commit. Repositories live in your organisation. If we set them up, we transfer them before the first invoice.
What happens when the engagement ends?+
You get runbooks, architecture notes and a recorded walkthrough. We stay available for questions for a month at no cost, because a handover that needs us on retainer is not a handover.