We build the
infrastructure layer
underneath your product.
FixedLayer Labs is a small engineering studio. We design, build, and run the AI, cloud, data, and automation layers that modern businesses depend on — the parts that are too important to outsource to a template shop and too expensive to keep in-house.
a real entry from a real engagement this month
— 01 / How we think
A product is just
layers stacked
on top of each other.
Most engineering problems look like product problems until you trace them down a layer. We work bottom-up: get the infrastructure honest, then the cloud, then the app, then the AI on top. The order matters.
↓ pick a layer
- The reason all of this exists. Every layer below is only valuable insofar as it helps a business ship faster, serve more customers, or charge more for what it sells.
- Custom LLM workflows, retrieval pipelines, and agents that do real work in production. We treat AI as a dependency to engineer around, not a feature to demo.
- The boring, valuable glue between your tools. We replace manual handoffs with event-driven systems that don't break the third time someone changes a field name.
- Web apps, internal tools, customer portals. Built with Next.js and TypeScript. Fast, accessible, and boring in the way that good production software is boring.
- AWS, Azure, or GCP. Multi-cloud when it earns its keep, single-cloud when it doesn't. Serverless where the workload fits, containers where it doesn't.
- Terraform, Kubernetes, networking, secrets, observability. The stuff nobody wants to write twice. We do it once, document it, and hand you the keys.
- We're the team that designs the layers, builds them, and keeps them running when things break at 2am. One studio, one accountable team, no outsourcing.
— 02 / What we actually do
Five kinds of work. One studio.
AI & agents
The thing everyone is asking for, done properly.
RAG pipelines, custom LLM agents, and internal copilots. We pick the model, design the retrieval, build the eval suite, and ship something your team can actually use on a Monday morning.
a thing we measure
0×
faster than the chatbot we replaced, on average
Applications
Next.js, React, TypeScript. Customer-facing products and internal tools. Fast, accessible, and written so the next engineer can read it on day one.
Cloud & platform
AWS, Azure, or GCP. We pick one and stick to it unless multi-cloud genuinely earns the operational cost. Kubernetes when you need it, serverless when you don't.
Data engineering
ETL/ELT pipelines, warehouses, and the boring-but-critical work of making sure the data your AI and dashboards depend on is actually correct.
Automation
Connecting the tools you already pay for so they actually talk to each other. Event-driven, observable, and documented well enough for a non-engineer to debug.
— 03 / A position we hold
Most companies don't have a product problem.
They have a foundation problem.
We get called in when a product is "stuck" — features that should take a week take a quarter, AI experiments that should take a day take a month, and every outage is a forensic investigation. Almost every time, the root cause is the same: the layers underneath the product were never designed to be changed. We rebuild them so the business can move again.
What we usually find
The stack is one thing pretending to be many.
- One git push, three services down.
- A new feature ships once a quarter because every change risks something.
- Adding an LLM means rewriting the auth flow.
- Nobody on the team is sure which database is the source of truth.
What it looks like after
The stack is layers that can change independently.
- Deploys happen daily, sometimes hourly, and roll back in under a minute.
- New engineers ship a real change in their first week.
- The AI layer is one service among many, not a religion.
- Every layer has an owner, a doc, and a runbook.
We don't sell a framework. We make a stack that fits your team, then we hand it over.
— 04 / The toolbox
The technologies we reach for, and the ones we don't.
We don't pick tools to look modern. We pick them because we've used them in production, debugged them at 2am, and know when they break. Here's what the shortlist looks like.
- Next.jsApp Router, RSC, edge runtimeReactHooks, server components, suspenseTypeScriptstrict, no any without a fightTailwindfor speed; CSS modules for the rest
- Node.jsTypeScript, Fastify, tRPCPythonFastAPI, Pydantic, asyncioGofor the parts that need to be fast
- PostgreSQLthe default; rarely the wrong oneRedisqueues, caches, sessionsSupabaseauth + realtime when it fitsPinecone / pgvectorretrieval for the AI layer
- AWSthe most common pickAzurewhen the client is already thereDockereverything ships in a containerKubernetesonly when it earns the complexityTerraforminfra as code, always
- OpenAIGPT-4o, o1, embeddingsAnthropicClaude for the careful workLangChainsparingly, with escape hatchesLlamaIndexfor heavy retrievalBraintrustevals, because vibes don't ship
// don't see something? we use plenty more. ask.
— 05 / How an engagement actually goes
Four phases. No surprises.
Every engagement we take follows roughly the same arc. The dates move around, the deliverables don't.
- 01
Discovery
1–2 weeksWe start by reading your code, not pitching you. We sit with your team (or what's left of it), walk the architecture, look at your last three incidents, and write up a one-page brief: what's working, what's not, and what we'd do first. No slides.
→ A written brief, owned by you.
- 02
Architecture
1–3 weeksWe draw the new layers before we build them. Schema, service boundaries, deployment topology, AI integration points, cost model. You see the diagram and the bill before anyone writes code.
→ Diagrams, ADRs, a costed plan.
- 03
Build
OngoingSmall senior team, weekly shipping, real pull requests you can review. We write tests, write docs as we go, and demo something working every Friday. No black-box phases.
→ Working code, weekly demos.
- 04
Run
After launchWe don't disappear at launch. We stay on for observability, on-call, and the small-but-important work nobody else wants to do. When your team is ready, we hand over cleanly.
→ A stack your team owns.
— 06 / How we work with you
You'll know what we
will and won't do.
Working with us is short, direct, and slightly opinionated. We're not the right fit for every project. Here's what you can expect either way.
We will
- Tell you when an idea is a bad idea, even if you came to us to build it.
- Push back on the framework choice in your RFP.
- Show up to your standup, not just the kickoff.
- Write the documentation your future engineer will need.
- Hand over the keys. We don't hold your stack hostage.
We won't
- Promise a date we can't keep to win the deal.
- Hide what we're doing behind a project manager.
- Use your engagement to train a model.
- Outsource the hard parts to a junior we just hired.
- Bill you for a meeting that could have been an email.
— 07 / From the workshop
Notes from real builds,
not thought leadership.
Architecture
The layer architecture philosophy, and where it falls apart.
Decoupled layers are the right default. But the usual pitch misses the cost: more services, more failure modes, more on-call. Here's how we decide where to stop splitting.
— 08 / If you got this far
Tell us what's slow, broken, or impossible on your stack.
We'll read it personally, and reply within a working day with whether we think we're the right team for it. If we're not, we'll tell you who probably is.