Cover: Where to Host a Prompt Library: Langfuse, Promptfoo and DIY
October 18, 2026·11 min read·2,345 words·

Where to Host a Prompt Library: Langfuse, Promptfoo and DIY

Self hosted prompt management means keeping your prompt library, version history and evaluation logs on infrastructure you control, rather than handing it to a vendor's SaaS (software as a service). The main open tools are Langfuse, Promptfoo, Latitude and PromptLayer's self-host tier, plus the option of a plain Git repository if you don't need a dashboard at all. Self-hosting buys you data control and predictable cost, but Langfuse alone needs Postgres, ClickHouse and a properly sized VPS (a virtual private server, a slice of a physical machine you rent and control) before it runs well.

What actually counts as "self hosted prompt management"?

It means the prompt text, version history, test results and access logs sit on a server you pay for and patch yourself, not on a vendor's shared cloud. That distinction matters if you handle client data, regulated content, or anything you'd rather not see sitting in a third party's logging pipeline.

A working prompt library usually holds more than just the prompt text. Before picking a tool, work out what you're actually hosting:

  • The prompt template itself, with placeholders and version history
  • Evaluation results, showing which version performed better and why
  • Trace logs, recording the actual inputs and outputs sent to the model
  • Access control records, showing who edited or approved a prompt change

Most teams start with a Git repo for the text alone, then bolt on a proper tool once they need evaluation and tracing too. We cover the same infrastructure question one layer up the stack in our guide to self-hosting AI agents on the HostList blog, worth a read if your prompt library sits next to a running agent.

What are the Langfuse self-hosting requirements?

Langfuse v3 needs Postgres for transactional data, ClickHouse for traces and analytics, Redis for caching and background jobs, and S3-compatible object storage for larger blobs, all wired together with Docker Compose (a tool for running multiple containers as one stack). A 2 vCPU, 4 GB VPS is the documented baseline, but that's a floor for testing, not a number a real team should get comfortable with in production.

ClickHouse in particular wants fast disk. Run it on the same small VPS as Postgres and Redis and you'll see slow queries the moment trace volume grows. Most self-hosters end up giving ClickHouse its own volume, or moving to a bigger box once daily trace counts climb into the tens of thousands.

You are a hosting consultant helping me size infrastructure for Langfuse (an open source prompt management and LLM observability tool). Ask yourself what data volume matters before answering: number of traces per day, retention period, number of team members, and whether ClickHouse (a columnar database Langfuse uses for analytics) needs its own disk. Given {daily_traces} traces per day and a retention of {retention_days} days, walk through your reasoning for CPU, RAM and disk, then give a final VPS spec recommendation with a fallback if my budget is under {monthly_budget}.

What it gets wrong: AI models routinely recommend one all-in-one VPS for Postgres, ClickHouse and Redis together, ignoring that ClickHouse's disk I/O pattern degrades everything else once trace volume rises. They also underestimate that retention period, not team size, is usually the bigger driver of disk cost.

Verify it: compare actual VPS specs and disk types on our VPS hosting picks before committing, and check the cloud hosting glossary if terms like "block storage" or "object storage" are unfamiliar.

Langfuse vs Promptfoo vs Latitude vs PromptLayer vs a Git repo: which should you use?

Langfuse suits teams that want tracing and evaluation in one dashboard. Promptfoo is lighter, built around testing prompts against expected outputs, without the full observability stack. Latitude and PromptLayer sit closer to managed products with an optional self-host tier bolted on, and a plain Git repo is the right call if all you need is version history.

ToolBest forDatabase requirementsSSO on self-hostGit-native versioning
LangfuseTracing, evaluation and prompt versioning in one placePostgres, ClickHouse, Redis, S3-compatible storagePaid tier requiredNo, uses its own DB history
PromptfooAutomated testing of prompt outputs against expected resultsNone required, runs config-basedNot applicable, CLI-firstYes, configs live in your repo
LatitudeProduct teams wanting a hosted-feeling UI on their own serverPostgres plus a queue serviceEnterprise tier onlyPartial, exports available
PromptLayerLogging and analytics for existing LLM API callsPostgresEnterprise tier onlyNo
Plain Git repoSmall teams needing version history, nothing elseNoneInherits your Git host's SSOYes, natively
You are helping me choose between Langfuse, Promptfoo, Latitude, PromptLayer and a plain Git repo for storing and testing our prompts. First build a checklist of what actually matters for my team: whether we need automated evaluation, whether we need request tracing, our team size, and our tolerance for running extra databases. Using {team_size}, {needs_tracing}, and {compliance_requirement}, reason through each option against that checklist, then give one final recommendation with the single biggest trade-off I'm accepting.

What it gets wrong: most models default to recommending Langfuse for every team, even a solo founder who only needs version history. They rarely mention that Promptfoo needs no database at all, which is often the simpler place to start.

Verify it: browse the HostList directory for providers that already offer one-click Docker Compose stacks, since that alone removes half the setup pain regardless of which tool you pick.

How much does self-hosting a prompt library cost compared to managed?

Self-hosting trades a monthly subscription for server rent plus your own time. At small scale that trade usually favours self-hosting. Once a team grows past a handful of engineers, the hours spent patching and monitoring often outweigh whatever you saved on licensing.

  • Solo founder or small team: a single VPS running Langfuse or Promptfoo costs far less than any managed plan, and setup is a one-off weekend job.
  • Growing startup (five to fifteen people): costs even out once you add backups, monitoring and someone's time to patch Docker images monthly.
  • Larger team (thirty-plus people): managed tiers with SSO, audit logs and support usually work out cheaper than the engineering hours needed to run the equivalent self-hosted setup properly.
You are a CTO advisor helping me build a total cost of ownership comparison between self-hosting Langfuse and paying for a managed prompt management tool. Show your checklist first: VPS cost, backup storage, engineer hours per month for patching, SSO licensing if required, and support overhead. Then, using {team_size} people and {monthly_llm_spend} as our monthly LLM API spend, give a plain-English recommendation on which option is cheaper over {time_horizon_months} months, and flag the one hidden cost I am probably underestimating.

What it gets wrong: AI cost comparisons almost always treat self-hosting as free once the VPS is paid for, leaving out the recurring engineer time to patch containers and rotate secrets. That single omission is usually enough to flip the recommendation.

Verify it: price real VPS and cloud options on our cloud hosting comparisons rather than trusting a generic estimate, since actual provider pricing varies more than most AI answers let on.

What prompt templates should you actually keep in your library?

Three prompts earn their place in almost every hosting team's library: a spec extractor for cutting through marketing fluff, a terms of service summariser, and an incident postmortem writer. All three do better when you ask the model to show its reasoning before the final output, which is exactly what catches it inventing facts.

You are helping me build a searchable hosting spec library. Given the raw spec sheet or marketing text below, extract only verifiable facts: CPU cores, RAM, storage type, bandwidth caps, backup frequency, and support channels. First list what is stated explicitly, then list what is vague or missing entirely (such as "unlimited" claims with no defined limit), then output a clean table of confirmed specs only. Text: {raw_spec_text}
You are reviewing a hosting provider's terms of service (ToS) before I store it in our prompt library as a compliance reference. Read the text below, then work through a checklist: data retention rules, refund conditions, resource overage penalties, and any clause allowing suspension without notice. After the checklist, summarise in five plain sentences what a non-lawyer needs to know, and flag anything that needs a real solicitor's review. Text: {tos_text}
You are drafting an incident postmortem for our prompt library so the next engineer can search it later. Using the timeline and notes below, first reconstruct a chronological checklist of what happened, then separate root cause from contributing factors, then write the final postmortem in this structure: summary, timeline, root cause, impact, fix, prevention steps. Keep it under {word_limit} words and avoid blaming individuals. Notes: {incident_notes}

What it gets wrong: the spec extractor will often invent a number when marketing copy is deliberately vague, turning "unlimited bandwidth" into a stated figure instead of flagging it as unverifiable. The postmortem writer sometimes blames a named person despite being told not to, and the ToS summariser occasionally states legal conclusions with confidence it hasn't earned.

Verify it: cross-check any extracted spec against the provider's actual listing and HRI (our objective hosting ranking score) on the HostList directory, and never treat a ToS summary as legal advice without independent review.

How do you version and back up a self-hosted prompt library safely?

Keep prompt text in Git regardless of which tool you use for evaluation. Langfuse and similar tools version prompts inside their own database, not in a format that survives a botched migration cleanly. Back up Postgres, ClickHouse and any object storage separately, and actually test the restore.

You are helping me write a backup verification runbook for our self-hosted Langfuse stack. Show your checklist first: what needs backing up (Postgres database, ClickHouse data directory, S3-compatible object storage, environment secrets), how often each changes, and where restore testing usually goes wrong. Then write a step-by-step runbook I can run monthly to prove backups actually restore, using {backup_tool} on a {vps_provider} VPS, and tell me the one failure mode most teams miss.

What it gets wrong: models commonly treat Postgres and ClickHouse backups as interchangeable, when ClickHouse needs its own backup mechanism separate from a standard pg_dump. They also rarely push hard enough on actually restoring the backup rather than just confirming a file exists.

Verify it: check that your VPS provider supports snapshots on our VPS hosting comparisons, and read up on storage terminology in the cloud hosting glossary if "object storage" or "block volume" need explaining.

How do you add SSO and restrict access for a team?

SSO (single sign-on, letting staff log in with one company identity rather than separate passwords) is usually gated behind a paid or enterprise licence, even in tools that call themselves open source and self-hosted. Budget for that licence if a client or auditor is going to ask for it.

You are auditing access control for our self-hosted prompt library before a client compliance review. Walk through a checklist first: who has admin access, whether SSO is enforced, whether API keys are scoped per project, and how former employees get removed. Then, based on {team_roster} and {current_setup}, list the specific gaps in order of risk, and give the exact configuration change needed to close the top three.

What it gets wrong: AI answers often assume SSO comes free with any self-hosted open source tool, when several of the tools compared here gate it behind a paid licence even for self-hosters. They also tend to skip API key scoping entirely.

Verify it: check each vendor's actual licensing page rather than trusting a general answer, and browse the HostList directory for providers offering managed identity add-ons if you'd rather not run SSO infrastructure yourself.

Frequently Asked Questions

Is Langfuse free to self-host?

The core Langfuse stack is open source and free to run, but you still pay for the VPS, Postgres, ClickHouse and storage underneath it. Enterprise features like SSO and certain compliance controls sit behind a paid licence even in the self-hosted version.

Can I just use a Git repo instead of Langfuse?

Yes. For version history alone a Git repo works fine and needs no database. You lose built-in evaluation and tracing though, so pair it with Promptfoo if you want automated testing without the full observability overhead of Langfuse.

What VPS specs do I need for Langfuse in production?

The documented minimum is 2 vCPU (virtual CPU cores) and 4 GB RAM, but that's for testing, not production. Once daily trace volume grows, give ClickHouse its own fast disk and plan for more RAM to avoid slow queries.

Does self-hosting a prompt library help with GDPR compliance?

It helps by keeping data on infrastructure you control and can locate geographically, which makes data residency questions easier to answer. It doesn't automatically make you compliant, you still need proper access controls, retention policies and a documented data processing basis.

How is Promptfoo different from Langfuse?

Promptfoo focuses on testing prompts against expected outputs before deployment, run mostly from the command line with config files. Langfuse adds full tracing, analytics and a web dashboard, but needs Postgres, ClickHouse and Redis running alongside it.

Do I need ClickHouse for a small team?

If you use Langfuse, yes, it's a hard dependency for the trace and analytics features. If your team only needs prompt versioning without detailed tracing, Promptfoo or a plain Git repo avoids ClickHouse entirely.

The bottom line

Self hosted prompt management pays off fastest for small teams and anyone who values data control over convenience, provided you're honest about the ongoing patching and backup work it demands. Pick the lightest tool that covers what you actually need today, not the one with the longest feature list, and revisit the decision once your team or trace volume genuinely outgrows it.

Do this next: size your VPS using the resource sizing prompt above before you provision anything, start with Promptfoo or a Git repo if you don't yet need tracing, and set a recurring calendar reminder to actually test a backup restore, not just confirm a backup file exists.

HostList on LinkedIn
More independent hosting data

Follow HostList for new rankings, original research, and changes across the hosting industry.

Gautam Khorana
Gautam Khorana
Founder, HostList.io

Over 10,000 websites launched. Years managing thousands of client sites. Built HostList because the world deserves honest hosting advice.

LinkedIn →

RELATED ARTICLES

RadixSponsorPremium names that work like prime real estate400,000+ short, memorable premium domains across .tech, .store, .online, .site and more. 20,000+ already sold.See Radix premiums
.tech domains from RadixSponsor.tech: the address for what you buildPremium .tech names like cloud.tech and micro.tech, from Radix. Short, dictionary-word domains for tech brands.See premium .tech
.host domains from RadixSponsor.host: a domain that says what you doPremium .host names for hosting companies and infrastructure brands, from the Radix registry.See premium .host
GreenGeeksSponsorEco-Friendly WordPress Hosting DealFast WordPress performance backed by expert 24/7 support, free migration, daily backups and built-in security.See GreenGeeks
HostPapaSponsorFast, Reliable, & Affordable Web HostingLaunch, grow and manage your website with reliable hosting, easy tools and 24/7 PapaSquad support.See HostPapa

Promoted placement. Does not affect HRI, ranking order or eligibility.