BareProxy is an early-stage open-source project. This proposal is written for an investor who hasn’t heard of it yet. It covers the project as it stands today and the business that could be built on it. The amount and the form of the investment are not set yet. Project figures are measured unless they say computed or estimated. Contact: [email protected].
Project links: the project site is bareproxy.com, the code is on GitHub, and BareProxy is listed with the other open-source projects on SoftDevStudio.com.
Summary
BareProxy is a small web server and reverse proxy that explains every routing decision. It is one Go program. Ask it about a request that hasn’t happened yet and it says how it would handle it. Ask about one that has, and it says what happened. Before a config change goes live, plan lists exactly which requests would be handled differently.
Config changes break websites, and nobody can say beforehand what a change will do. nginx -t checks the syntax. Afterwards the logs don’t say which rule matched, or why a request got a 404 or a 502. Small teams and solo operators feel this most, because nobody is there to catch a mistake before the visitors do.
Version 0.1.0-alpha was finished on 5 October 2026 and is public at github.com/BareProxy/bareproxy under the Apache License 2.0. It runs on Linux only for now. In the acceptance tests plan was exact on all 1,000 generated config pairs. In a load test with 20 config changes during the run, none of 120,020 requests and WebSocket messages failed. A hands-on review inside the project (gate 1) passed the alpha with conditions, which are now fixed. There has been no outside review yet. A browser demo at bareproxy.com/demo runs the same code. It is slower than nginx: per core, nginx handled 1.9 to at least 3.2 times as many requests on our routes. There are no users or customers yet.
Nobody pays for a web server, so the server stays free. The money would come from what teams pay for around a free server: a plan check on every proposed config change, Guard, which rolls a change back when errors jump after it, and Fleet, which rolls one change out to many servers with one shared history. That is how F5 sells NGINX Plus and HAProxy Technologies sells HAProxy Enterprise, and how HashiCorp sold the team version of Terraform. Nothing earns until plan works on real sites and people use the free server. For this kind of business that takes years.
The founder hasn’t set the amount or the form of the investment yet. The plan in section 12 needs about $470,000 to $990,000 for 18 months (computed from estimates): two engineers, developer relations at half time, an outside security review and the trademark work.
The premise
Most sites and applications use a small part of nginx. They need HTTPS, a folder served as a site, rules that route by host name and path, and requests spread over backends that are up. They need config changes that don’t drop traffic, and a way to find out what happened to a request when something breaks. nginx can do far more than that, and each extra feature is more to learn and more to get wrong.
The question behind the project: how little machinery does it take to provide the part of nginx that most applications use?
BareProxy is the answer so far. Its core stays under 5,000 lines of Go and does that part only. Anything else becomes an add-on module, or is left out. Keeping the rules this plain is also what lets the server explain itself, and that is what this proposal is about.
The problem
Config changes break websites. The change is the risky moment: someone edits the rules in front of a site, reloads the server and finds out from the visitors what the change did.
Before a change, the tools check the file and stop there. nginx -t checks the syntax and tries to open the files the config names. HAProxy’s -c option checks the config files, and caddy validate loads a config without starting it. None of them says which requests will go somewhere else after the change. After a change, the logs say what happened to a request. They don’t say which rule decided it, or why a request got a 404 or a 502, so people read the config from the top and guess.
nginx configs grow by copy and paste, and its matching order surprises experienced people. nginx first finds the longest matching path prefix and remembers it. Then it checks the regular expressions in the order they appear in the file, and the first one that matches wins. Only when none matches does it fall back, after any predicate locations (new in nginx 1.31.5, September 2026), to the prefix it remembered. A regular expression added near the top of a long file can take requests away from a rule far below it, and nothing warns you.
Small teams and solo operators feel this most. They run a site and an app on a few servers, and there is nobody to catch a mistake before it goes live.
Large operators get caught at the moment of change too. Cloudflare’s outages of 18 November 2025 and 5 December 2025 both started with a change: a database permissions change that doubled the size of a file its proxy reads, and a settings change pushed to its whole network within seconds. Neither was a routing change, so a routing check like plan would not have caught them. An automatic rollback when errors jump after a change, which is what Guard is meant to do, is closer to that kind of failure.
What exists today
Everything in this section is measured on the finished alpha unless it says computed, and comes from the logs in the repository. The code is public at github.com/BareProxy/bareproxy. The browser demo at bareproxy.com/demo runs the same code compiled to WebAssembly, so anyone can try explain and plan without installing anything.
| Area | What exists, and what we measured |
|---|---|
| Release | 0.1.0-alpha, finished on 5 October 2026. Linux only for now: static binaries for amd64 (8.9 MB) and arm64 (8.3 MB) in the repository. The arm64 binary is built but hasn’t been run yet. Built with Go 1.27.1. |
| License | The entire project runs under the Apache License 2.0 for now, Copyright 2026 BareProxy.com. Premium add-ons may be offered later under different licenses. |
| Size | 5,225 lines of Go in the core and the command (core 4,767, command 458), without blank lines and comments. File serving (235 lines) has its own budget, so 4,990 lines count against the core’s budget of 5,000. |
| Dependencies | Go’s standard library, plus three modules from the Go project itself: golang.org/x/crypto for automatic certificates, and x/net and x/text, which it pulls in. |
| Unit tests | 129 test functions (3 run only when asked for) in 8,056 lines of test code. go test and go test -race pass. |
| explain | 100,000 generated requests: explain, asked first, and the running server agreed on every one. |
| plan | 1,000 generated config pairs, with 300,000 requests: plan was exact on every pair. |
| Bad input | 71 broken configs: none went live. 91 request smuggling payloads: 0 problems. 30,000 generated paths and 127 written cases: nothing outside the site’s folder was read. |
| Load | 2,000 requests per second for 60 seconds over HTTP/1.1, HTTP/2 and WebSocket at once, with 20 config changes (apply) during the run: 120,020 requests and WebSocket messages, 0 failed, 0 connections reset, 0 WebSocket messages lost. After each change the next requests already followed the new config. All 14 full runs passed. p99 latency on a quiet machine: 2.5 ms over HTTP/1.1, 2.7 ms over HTTP/2 and 2.3 ms for a WebSocket echo. |
| Memory | Peak 46 MiB under the full load test with the default record store of 8 MB (47 MiB in the run on the final code), and 25 MiB with the store off. |
| Review (gate 1) | A hands-on review inside the project, on a real config, passed an earlier build of the alpha on 5 October with conditions and no blockers. It was not an outside review. Removing a backend under load: 45,518 requests in 8 seconds, 0 failures. Its conditions and its five minor items are fixed. |
| Demo | The same code compiled to WebAssembly: 114 checks pass in headless Chromium against the native commands. |
| Live test | The bareproxy.com site served over HTTPS: 24 requests, 24 records. |
Against nginx
We measured BareProxy against nginx 1.24.0 on the final build: one core each, the same routes, a shared cloud machine with 2 CPUs, where no run lost more than 10% of a core to other work, the best of 3 runs of 10 seconds, logging off. Requests per second:
| Route | BareProxy | nginx 1.24.0 | Note |
|---|---|---|---|
| Home page | 21,819 | 66,136 | |
| 72 KB image | 17,769 | 57,095 | a floor for nginx: the load generator was the limit |
| Missing page (404) | 24,278 | 46,762 | |
| Proxied API | 12,055 | 35,432 |
Per core, nginx handled 1.9 to at least 3.2 times as many requests (computed from the best runs). Idle, BareProxy used 8.0 MiB of memory. nginx used 11.4 MiB, or 6.0 MiB when the memory its processes share is counted once (PSS). At the peak of this test it was 38.8 MiB against 12.4 MiB. The speed work on 5 October took the proxied API from 10,430 to 12,055 requests per second (nginx stayed at about 35,400 in both measurements), and cut the memory allocated per proxied request from 43.7 KB to 10.3 KB. BareProxy was built to be small and to explain itself, and speed came second.
Not done yet
-
Let’s Encrypt itself hasn’t issued a certificate to BareProxy yet. Automatic certificates were tested against Let’s Encrypt’s Pebble test CA, and a real issuance needs a public name on a server.
-
The trademark search on the name (gate 2) is open, so the name isn’t cleared yet.
-
There has been no outside security review.
-
macOS and Windows builds are not started.
-
None of the eight planned modules is built.
-
There are no users or customers yet, and nobody who runs nginx has been asked whether they would switch.
-
There is no hired team.
How it works, and why plan can be exact
Every website has a front door that sends each request to a file or to the application behind the site. nginx is the best-known front door. BareProxy is a small one that keeps notes. For every request it can say which rule it followed and where the request went. Ask it about a request that hasn’t happened yet and it says what it would do. Before a rule change, it lists exactly which requests would be handled differently.
Think of a mail room. Every letter gets a slip naming the rule that sent it to its desk. Before the sorting rules change, the clerk tells you which letters would land on a different desk.
The rules live in one config file. Each route line is a rule, and the first one that fits a request decides what happens to it:
site example.com tls /etc/bareproxy/example.com.crt /etc/bareproxy/example.com.key error 404 /404.html route /healthz -> respond 200 "ok" route /api/* -> api strip route /* -> files /var/www/example/public pool api backend 10.0.0.11:8080 backend 10.0.0.12:8080 backend 10.0.0.13:8080 health /healthz
The commands:
-
explain says how a request would be handled before it arrives: which rules it checked, which one matched and what would happen.
-
why takes the short ID that every response carries and says what happened to that request, backend by backend.
-
plan compares a new config with the running one and lists the kinds of request that would be handled differently.
-
apply –plan ID applies exactly the plan that was read, and refuses if either config has changed since. rollback goes back to an earlier version, and the history keeps the last 100.
Here plan compares that config with a new one that sends /api/v2 to a new pool and points the site at a new release folder. This is the real output of the alpha, with its last line wrapped to fit the page:
$ bareproxy plan new.conf Compared with running version 1: Plan fed3ae3003fe: 2 routing changes, 1 other change Routing example.com (port 443), any method, /api/v2 and below pool api, strip /api -> pool api-v2, strip /api/v2 example.com (port 443), any method, every path except /healthz and /api and below files /var/www/example/public -> files /var/www/example/release-42 Other changes pool api-v2 added (line 23): backend 10.0.0.21:8080, backend 10.0.0.22:8080, health /healthz
Why the plan can be exact
Every BareProxy rule matches on plain values: a host name, an exact path or a path prefix, a method, a header value. There are no regular expressions and no URL rewriting, apart from cutting a prefix off the path. So the requests a site can get fall into a finite number of classes, and every request in a class is handled the same way.
plan builds those classes from the old and the new config together. It runs the server’s own matching code on one request from each class, under both configs, and lists the classes whose handling changes. Nothing is sampled, so for routing nothing is missed: every kind of request that changes is listed, and no other. In the acceptance tests it was exact on all 1,000 generated config pairs.
Two limits come with it. plan compares routing and never looks inside a folder, so pointing a site at a new release folder is one change, whatever files are in it. And on a very large site the number of classes can pass one million. Then plan says so, and lists the changed rules instead.
explain runs the same matching code as live traffic, with notes switched on, so the answer and the live server can’t drift apart. A test checks that anyway: on 100,000 generated requests they agreed every time.
The price is the rule language. A site that needs regular expressions or URL rewriting can’t use BareProxy today. That limit is on purpose, and section 6 explains why it is also the moat.
What sets it apart, and the moat
-
It explains itself, with the same code that handles live traffic: explain before a request, why after it.
-
plan is exact for routing. As far as we know, none of the big servers offers that. On 5 October 2026 we looked through the documentation of nginx, Caddy, HAProxy, Traefik and Envoy for a command that compares two configs by the requests they would handle differently, and found none. nginx -t, haproxy -c and caddy validate check that a config is valid. In Traefik, a maintainer answered a request for a config check command that it would add little over starting Traefik itself. Envoy has a route table check tool that tests a routing config against test cases you write yourself and reports how many routes they cover. It doesn’t compare two configs.
-
It is small. The core is under 5,000 lines of Go, and the whole program, a web server and a proxy in one, is 5,225.
How weak the moat is
The moat is weak at the start. The code is under the Apache License 2.0 and small, so anyone can copy it.
The real moat is the limited rule language. An exact plan only works because BareProxy has no regular expressions and no URL rewriting. Users of nginx, Caddy, Traefik and Envoy depend on both, so those servers can’t make the same promise without breaking their users’ configs.
History adds a switching cost over time. Once a team’s versions, plans and request records live in BareProxy, leaving means giving up rollback, plan and why over that history. Fleet makes that stronger, because the history is then shared across servers and people.
The weak spots, as we see them:
-
Caddy is already simple, and it uses TLS by default.
-
nginx is installed everywhere: W3Techs counts it on 30.8% of the websites whose web server it knows.
-
There is no network effect. One more user doesn’t make BareProxy better for the next one.
-
Nobody who runs nginx has been asked yet whether they would switch.
-
explain on its own is easy to copy.
Market and competition
Who would use it, and who would pay
The first users would be small teams and solo operators who run a site and an app on a few servers, with one program and one config file in front of both. They would use the free server.
The people who would pay are teams for whom a bad config change costs money. The plan check and Guard are for them, and Fleet once they run more than a few servers. Later, if the plan check is offered for Kubernetes Gateway API routes, platform teams on Kubernetes could pay for it too (section 9).
The figures we can cite
-
nginx runs on 30.8% of the websites whose web server W3Techs knows. Cloudflare’s server is at 31.3%, Apache 21.9%, LiteSpeed 14.3%, Caddy 1.1% and Envoy 0.5%, and a site can use more than one (figures of 4 October 2026).
-
When F5 bought NGINX in 2019, it said NGINX was trusted by more than 375 million sites.
-
HashiCorp, the company behind Terraform and other infrastructure tools, reported revenue of $583.1 million for its fiscal year 2024, up 23%, from 4,423 customers, 897 of them with $100,000 or more in annual recurring revenue. The figure is for the whole company, Terraform and its other products together.
-
The Kubernetes project retired ingress-nginx, a widely used Ingress controller built on nginx. Maintenance ended in March 2026, the repository was archived on 24 March 2026, and its users are pointed to Gateway API.
We haven’t found a reliable figure for how many teams would pay for a config change check, and we don’t give one.
Competitors, free and paid
Every server below is free. The paid layers sell management and support on top:
| Server | License | Paid layer | Check before a change |
|---|---|---|---|
| nginx | BSD 2-clause | NGINX Plus from F5: active health checks, changes through an API without reloads, metrics, support | nginx -t: the syntax, and that the files open |
| HAProxy | GPL 2 or later | HAProxy Enterprise, with HAProxy Fusion to manage fleets: versioned config, dashboards, access control | haproxy -c: checks the config files |
| Traefik | MIT | Traefik Hub API Gateway and Traefik Hub API Management | None built in; a maintainer saw little value in one |
| Caddy | Apache 2.0 | Not covered in this draft | caddy validate: loads the config without starting it |
| Envoy | Apache 2.0 | Not covered in this draft | Route table check tool: tests against cases you write |
| BareProxy | Apache 2.0, for now | Planned: the plan check, Guard, Fleet, support | plan: every class of request whose handling changes, exact for routing |
The NGINX Plus, HAProxy Fusion and Traefik pricing pages we cite show no prices (looked at on 5 October 2026). HAProxy and Traefik ask buyers to contact sales. So there is no public price to compare with.
The closest model: Terraform
terraform plan shows the changes Terraform would make before it makes them, and it is free. HashiCorp earned its money from the team version: HCP Terraform is free for up to 500 managed resources, and policy enforcement and audit logging are in the paid plans. Atlantis, an open source tool, runs terraform plan on pull requests and posts the output as a comment. That is the shape of the plan check we would sell, for web server configs.
Business model
Open core. The entire project runs under the Apache License 2.0 for now, Copyright 2026 BareProxy.com. Later, premium add-ons may be offered under different licenses. Which add-ons, and under which licenses, isn’t decided.
Nobody pays for a web server: nginx, Caddy, HAProxy, Traefik and Envoy are all free. The money comes from running many servers safely. NGINX Plus, HAProxy Enterprise and Traefik’s paid tiers sell management and support on top of a free server, and F5 bought NGINX in 2019 for a total enterprise value of about $670 million.
BareProxy would follow the same pattern. The server stays free, so people adopt it, and these would be paid:
| Product | What it does | How it would be sold | Status |
|---|---|---|---|
| The server | Everything in the alpha, and the modules as they are built. | Free, under the Apache License 2.0 | Alpha |
| Plan check | Runs plan on every proposed config change before it is merged, posts which requests will be handled differently, and keeps the history. | A service, and the first thing we would charge for | Not built |
| Guard | Rolls a change back by itself when errors jump after it. | Per server, or in the hosted control panel | Not built |
| Fleet | One change rolled out to many servers, with a shared history and search across request records. | Per server, or as a hosted control panel | Not built |
| Support | Help and fixes for teams that run BareProxy in production. | A yearly subscription | Not started |
No prices are set. We would set them with the first teams that use the plan check.
Timing. Nothing earns until plan works on real sites and people use the free server. For this kind of business that takes years, and this proposal assumes so.
Go to market
The plan has stages, and each one starts when the one before it works.
Stage 1: the free server and the demo
The demo at bareproxy.com/demo runs the real parser, explain and plan in a browser. Someone can paste a config and try plan in a minute, without installing anything. The first users we would go after run a static site and an API on a few servers, for example a Hugo site with an application behind it.
The first job is to ask people who run nginx whether they would switch, and for what. Nobody has been asked yet, and the answers decide how much of the rest of this plan holds.
Stage 2: the plan check for teams
plan as a check on every pull request that changes the config. It posts which requests will be handled differently and keeps the history, the way Atlantis does for Terraform. This is the first thing we would charge for. Guard comes next, then Fleet for teams with more servers.
Stage 3, later: the change check for other servers’ configs
If plan and explain are where the value is, asking people to switch servers may be the wrong link in the chain. The same check could serve the servers people already run, with BareProxy as the engine, and as the reference where a plan is exact. This is a later stage of the plan, and nothing about it is decided. The founder raised it as an open question on 3 October 2026.
The place to start is where an exact answer is possible. Kubernetes retired ingress-nginx in March 2026 and pointed its users to Gateway API. Gateway API routes match exact paths and path prefixes in its core, and regular expressions are an optional extra that each implementation handles its own way. That is close to BareProxy’s rules. A migration tool, ingress2gateway 1.0, came out on 20 March 2026. For Gateway API routes without regular expressions we expect an exact plan to be possible, though we haven’t built it.
On nginx it costs more. Regular expressions, rewrites, if, map and, since nginx 1.31.5, locations that match on any variable limit how exact a plan can be, so a plan for nginx configs would be exact only for configs that avoid them, and it would have to say where it isn’t.
Roadmap and milestones
Done
From the changelog:
| Date | Milestone |
|---|---|
| 1 October 2026 | Design note: the config grammar, the commands, plan, tracing and the acceptance tests. |
| 2 October 2026 | First cut, 0.1.0-dev. |
| 3 October 2026 | Public repository on GitHub. |
| 5 October 2026 | 0.1.0-alpha finished, and gate 1, a hands-on review of the alpha inside the project, passed with conditions. |
Next, in the project plan
These are the next steps in the project plan, in order. Each starts when the founder says go:
-
A real Let’s Encrypt certificate on a public name, and a check of the Go module sums once the build machine can reach the Go module proxy.
-
The trademark search on the name (gate 2).
-
More speed work, if wanted: a fast path for paths that are already normal, and fewer system calls on static files.
-
macOS and Windows builds, with the test suite run on each.
-
An outside security review, before anything that matters runs behind BareProxy.
-
The add-on modules, one at a time, in the order the founder picks. The suggested order is Compress, Limit and Split, then Cache, Auth, Guard, Export and Fleet.
With the investment
The investment would put people and a calendar behind those steps, and add the paid products. Months count from the funding. Every month here is an estimate, and the founder will set the order with the first users:
| Months | Milestone | What it shows |
|---|---|---|
| 1 to 3 | The trademark search done, or a new name chosen. The outside security review done and its findings fixed. macOS and Windows builds. Talks with teams that run nginx, and the first teams running BareProxy on a real site. | Whether people who run nginx would switch, and what for. |
| 4 to 9 | The plan check on pull requests, in a trial with the first teams. Guard. The first modules: Compress, Limit and Split. Version 1.0, once the review’s findings are fixed and real sites have run it. | Whether teams use the plan check, and whether they would pay for it. |
| 10 to 18 | Fleet and the hosted control panel. The first teams asked to pay. A first look at the plan check for Gateway API routes. | Whether teams pay, and whether the later stage is worth starting. |
Team
Today the project has one person: the founder, as product owner. The founder set the premise and decides at each of the project’s gates. There is no hired team yet, and a single maintainer is a risk (section 13).
The money would hire these roles:
| Role | From month | Months | What the role does |
|---|---|---|---|
| Senior Go engineer, servers and networking | 1 | 18 | The core, the fixes from the outside review, the macOS and Windows builds, Guard and the modules. |
| Engineer for the hosted service | 7 | 12 | The plan check service, the control panel for Fleet, accounts and billing. |
| Developer relations and support, half time | 1 | 18 | Docs, examples and the demo; talking to teams that run nginx; the first support. |
Outside help, paid by the job: a security firm for the outside review, a trademark lawyer and an accountant.
The ask and the use of funds
The founder hasn’t set the amount or the form of the investment yet. This section builds the money from roles and months, so the amount can be set from it. Every amount is an estimate in US dollars. What a person costs depends on where they are hired, so we use $10,000 to $20,000 a month for a full-time person, all costs included. That is an assumption, to be replaced by real offers.
The project plan sizes its next engineering steps in hours of working time, for first working versions. The months here pay for making them fit for production, for the hosted service and support, and for the work with the first teams.
| Item | Basis | Low | High |
|---|---|---|---|
| Senior Go engineer, servers and networking | 18 months, at $10,000 to $20,000 a month | $180,000 | $360,000 |
| Engineer for the hosted service | 12 months, from month 7, at $10,000 to $20,000 a month | $120,000 | $240,000 |
| Developer relations and support, half time | 18 months at half time (9 full-time months), at $10,000 to $20,000 a month | $90,000 | $180,000 |
| Outside security review of the core | One review by a security firm, plus a check of the fixes. | $15,000 | $40,000 |
| Trademark search and filing | The search of gate 2, then filing in the main markets if the name clears. | $3,000 | $15,000 |
| Hosting, test machines and the hosted service | $500 to $2,000 a month for 18 months. | $9,000 | $36,000 |
| Legal and accounting | Contracts, the investment papers and the books. | $10,000 | $30,000 |
| Subtotal | $427,000 | $901,000 | |
| Contingency | 10% of the subtotal | $42,700 | $90,100 |
| Total | Computed from the estimates above | $469,700 | $991,100 |
So the plan needs about $470,000 to $990,000 for 18 months (computed from the estimates). The founder’s own pay is not in these figures.
What the money buys is the milestones in section 10: the name settled, the outside review done, the plan check and Guard in use with the first teams, and Fleet started. What it doesn’t buy is a business that pays for itself. We don’t expect the paid products to cover the costs within these 18 months, so after them the company would need revenue, a further round, or both.
Risks
These are the risks we know of, with where each one stands:
| Risk | Where it stands, and what we would do |
|---|---|
| Nobody may want to switch | There are no users or customers yet, and nobody who runs nginx has been asked whether they would switch. Talking to them is the first job of the money, and their answers set the order of everything after. |
| The name isn’t cleared | The trademark search (gate 2) is open. If the name doesn’t clear, the project changes its name before wider promotion. |
| One maintainer | Today one person holds the project. The first hire, in month 1, is a senior engineer who can own the core. |
| No outside security review | BareProxy hasn’t had one, and its README says not to put it in front of anything that matters yet. The review is planned for months 1 to 3. |
| Linux only | macOS and Windows builds are not started. They are planned for months 1 to 3. |
| Not yet proven in the field | Let’s Encrypt itself hasn’t issued a certificate to BareProxy yet (it was tested against the Pebble test CA), and the arm64 binary is built but hasn’t been run. |
| A weak moat at the start | The code is Apache 2.0 and small, and anyone can copy it. explain on its own is easy to copy. The moat that holds is the rule language that makes plan exact, and the history a team builds up (section 6). |
| Caddy is already simple | Caddy is simple and uses TLS by default. BareProxy has to win on plan and explain. Simplicity alone won’t do it. |
| nginx is everywhere | nginx runs on 30.8% of the websites whose server W3Techs knows. The later stage, the change check for other servers’ configs, goes to where people already are. |
| No network effect | One more user doesn’t make BareProxy better for the next one. Growth has to come from the product, and from the history that builds up in it. |
| The rules keep some sites away | The limit that makes plan exact also means that sites needing regular expressions or URL rewriting can’t use BareProxy today. |
| Slower than nginx | Per core, nginx handled 1.9 to at least 3.2 times as many requests on our routes (computed). BareProxy is built to be small and to explain itself, and we say so. |
| Licenses later | Premium add-ons may come under other licenses. When HashiCorp moved its products, Terraform among them, from the Mozilla Public License to the Business Source License in August 2023, a fork followed: OpenTofu, now a Linux Foundation project. Any license for add-ons has to be clear before anyone depends on them. |
| It takes years | Nothing earns until plan works on real sites and people use the free server. The money here covers 18 months and doesn’t assume revenue in them. |
What an investor gets, and exits in this market
An investor would hold a stake in the legal entity that owns BareProxy: the project, its name once the trademark search clears it, and the paid products as they are built. Which entity that is, and the form of the investment (shares, a SAFE or a convertible note), are for the founder to confirm.
Two exits in this market are well known:
-
F5 agreed in March 2019 to buy NGINX, the company behind nginx and NGINX Plus, for a total enterprise value of about $670 million, paid from its own cash.
-
IBM finished buying HashiCorp, the company behind Terraform, for $6.4 billion on 27 February 2025, ten months after it announced the deal.
Both show who buys in this market: large network and infrastructure companies, buying the company behind a free tool that many people already run. Both companies were far bigger than BareProxy is today. Nothing here promises an exit, or a price.
Follow the Project
Releases, test reports and documentation are published on the BareProxy project site and in the BareProxy repository on GitHub. BareProxy is one of the open-source projects listed on SoftDevStudio.com, and the AltSql investment proposal is the first project featured here.