# Fluxzero > The all-in-one cloud with frontend, backend, data, security, and observability working as one. ## Core pages - [Fluxzero — The European cloud for AI-built apps](https://fluxzero.io/): The all-in-one cloud with frontend, backend, data, security, and observability working as one. - [Inside Fluxzero — The application cloud](https://fluxzero.io/how-it-works/): See how Fluxzero keeps infrastructure out of your application so people and AI agents can focus on building the product. - [Product decisions are the code — Fluxzero](https://fluxzero.io/product-code/): See how everyday product features become simple code when Fluxzero handles the engineering underneath. - [How Fluxzero keeps products running — Fluxzero](https://fluxzero.io/technical-foundation/): See how Fluxzero gives every product the correctness, security, privacy, recovery, auditability, and scale enterprises require from day zero. - [Fluxzero Pricing — Build free. Launch, then run.](https://fluxzero.io/pricing/): Fluxzero pricing for builders: build locally for free, put your app online with Starter, then run with Startup, Scale Up, or Enterprise. - [About Fluxzero - Origin story](https://fluxzero.io/about/): The origin story behind Fluxzero, the European cloud for AI-built apps. - [Start building with Fluxzero](https://fluxzero.io/get-started/): Connect Fluxzero to your coding agent and start building your product. - [Contact Fluxzero](https://fluxzero.io/contact/): Contact Fluxzero for launch access, pricing questions, partnerships, and product feedback. --- # Fluxzero — The European cloud for AI-built apps Source: https://fluxzero.io/ ## The European cloud for AI-built apps The all-in-one cloud with frontend, backend, data, security, and observability working as one. [Get started →](https://fluxzero.io/get-started) [Talk to us](https://fluxzero.io/contact#contactForm) 100% EU-operated · Built on ISO 27001-certified and SOC 2 Type 2-audited infrastructure. ### The cloud for anyone AI lets anyone build products. Fluxzero gives every product a reliable backend from the first prompt. ##### Ship without an engineering team Build and launch serious products without assembling a backend or platform team. ##### Build with peace of mind Security, reliability, and recovery are built in from day one, not left for you or your agent to get right. ##### Scale without replatforming The same application model works locally and at full scale, so growth does not force a new architecture. ### Other clouds run infrastructure. Fluxzero runs your product. Infrastructure clouds leave you responsible for the tech stack. With Fluxzero, your only responsibility is the product. | Comparison category | Supabase + Vercel — Database platform + frontend cloud | Railway — Application infrastructure | Fluxzero — The product cloud | | --- | --- | --- | --- | | Built for | Developers | Developers | Anyone building with AI | | What you set up | Database, frontend hosting, permissions & integrations | Services, databases, networking, load balancing & deployment | No infrastructure setup | | What the cloud handles | Auth, database & frontend hosting | Deployments, networking & databases | Everything your product needs to run | | When your agent adds a feature | Builds the feature across every application layer | Builds the feature across services and infrastructure | Just adds the feature | | Security & recovery | Database backups; application recovery is left to you | Left for you to build into the application | Handled by the cloud | | Path to scale | Requires rearchitecting or replatforming | Requires rearchitecting or replatforming | Scale without rebuilding | | Based in | Singapore + United States | United States | European Union | [Explore how Fluxzero works →](https://fluxzero.io/how-it-works) No technical noise ### AI works better when it has less to think about When AI does not have to integrate cloud infrastructure, it can stay focused on the product behavior you actually care about. ##### Spend fewer tokens Spend your prompt budget on product behavior, features, and user experience. ##### Less risk Infrastructure is no longer your AI agent’s responsibility. ##### 100% product context The tech stack no longer consumes your agent’s context, so every prompt can stay focused on the product. Built to scale ### Start small. Scale as your product grows. The same foundation supports early products and high-throughput systems with complex business logic. - **GB / min production throughput:** 100 + Or about 700,000 tweets every second, nearly 5 times X.com’s record. [*](https://fluxzero.io/#tweet-throughput-note) - **resolved requests / sec:** 1 M+ Commands and results, end to end across applications. - **less application code:** up to 99% Across legacy migrations with the same behavior. * Estimate based on a [2.3 kB average serialized tweet size](https://www.research-collection.ethz.ch/bitstreams/77b38ad3-f165-4bda-9fca-6a1d13913836/download) and [X.com’s published record of 143,199 tweets per second](https://blog.x.com/engineering/en_us/a/2013/new-tweets-per-second-record-and-how). ### Frequently asked questions #### What is Fluxzero? Fluxzero is designed for the AI era. It is made for everyone building a product, not just engineers. Every product gets a reliable backend from day zero, so your agent can focus on the product instead of its tech stack. #### Can I really launch serious software on Fluxzero? Yes. Fluxzero is built for products where reliability matters: products with valuable data, complex workflows, permissions, integrations, and business rules. You and your coding agent build the product behavior. Fluxzero takes responsibility for the technical foundation underneath your product, including security, reliable message delivery, recovery, auditability, and scale. The same hardened foundation supports early-stage products and high-throughput enterprise workloads, so you can launch without hiring backend engineers and keep the same backend as your product grows. #### My agent can generate a backend. Why should it use Fluxzero? An agent can generate a backend quickly. But building your product is a different job from building a hardened backend. Your agent is focused on the product. The backend it generates becomes a codebase you must keep secure, reliable, understandable, and ready to scale as the product evolves. Every shortcut taken to launch becomes something you own. Fluxzero gives your product a hardened backend foundation built and operated by experienced backend engineers for demanding enterprise workloads. Because products run on a shared platform foundation, improvements to security, reliability, recovery, and scale compound and benefit every product, without adding infrastructure code to your application. Your codebase stays focused on the product. As usage and complexity increase, you keep building on the same foundation instead of rebuilding or replatforming. #### How is Fluxzero different from Supabase + Vercel, Railway, or other clouds? Those clouds give you infrastructure and services that still need to be selected, connected, secured, scaled, and operated. You or your agent remains responsible for turning them into one reliable product. Fluxzero provides and operates that application foundation as one cloud, so you can focus on the product instead of operating the platform underneath it. If you prefer to design, tune, and operate every infrastructure layer yourself, a component cloud may suit you better. #### What does building with Fluxzero look like? Start by copying one instruction into your coding agent. This is the easiest way to build with Fluxzero. The application your agent helps you build is real code that developers can inspect, test, and extend from their own IDE. When the product is ready, the same application can be deployed to Fluxzero Cloud. #### What kinds of products can I build? Any application can run on Fluxzero, across product domains and workload sizes. That includes SaaS products, marketplaces, portals, internal tools, consumer apps, and AI-enabled software. #### What kinds of companies run on Fluxzero? Fluxzero is trusted in production across product domains and workload sizes, from single-founder companies and scale-ups to enterprises such as the organization behind the digital infrastructure of Europe's largest port. #### Will I outgrow Fluxzero or need to rebuild later? No. The same application works locally and at production scale. Individual workloads can receive more capacity as your product grows, without forcing the whole product onto a new architecture. If developers join later, they work in a real codebase, not a generated black box. They can inspect, test, and extend the product in their own IDE while Fluxzero continues to run the foundation. #### Do I lose visibility by trusting my backend to Fluxzero? No. Fluxzero is not a black box. It works more like an X-ray of your product: you can see its messages, web requests, application logs, errors, and the user or system behind each interaction. Every interaction is part of a searchable audit trail. Correlation and tracing let you follow a single request across applications or zoom out to find patterns, performance issues, and failures across the whole product. #### Do I own my code and data? Yes. Your application code and product data remain yours. The code does not depend on proprietary Fluxzero annotations, and your data can be exported in a machine-readable format. #### When do I start paying? Building and running locally is free. You start paying when you activate a plan to put your product online. Still wondering? [Get in touch](https://fluxzero.io/contact) and we'll help. ### Launch what used to require an entire engineering team. [Get started →](https://fluxzero.io/get-started) [Talk to us](https://fluxzero.io/contact#contactForm) --- # Inside Fluxzero — The application cloud Source: https://fluxzero.io/how-it-works/ ## AI lets anyone build products. Time for the cloud to catch up. Fluxzero is the cloud for a new generation of builders. You decide what to build. Your agent builds it. Fluxzero makes it run. [Get started](https://fluxzero.io/get-started) [Read the technical docs](https://fluxzero.io/docs) ### More products should not mean more infrastructure. Traditional clouds were designed for engineering teams building and operating one product at a time. As AI creates more products, duplicating the same backend for each one no longer makes sense. #### Product 1 - Unique product logic - Services & workers - Persistence - Messaging & recovery - Gateways & proxies - Load balancing - Security & discovery - Observability - Deployment #### Product 2 - Unique product logic - Services & workers - Persistence - Messaging & recovery - Gateways & proxies - Load balancing - Security & discovery - Observability - Deployment #### Product N - Unique product logic - Services & workers - Persistence - Messaging & recovery - Gateways & proxies - Load balancing - Security & discovery - Observability - Deployment ### Your product should be the whole application. Traditional applications mix product features with the technical work needed to run them. With Fluxzero, the application contains only what makes the product unique. The cloud handles the rest. **Inside a traditional application** Everything below ships as part of the app - Product behavior - Service wiring and orchestration - Integration adapters - Persistence code and schemas - Retry and recovery paths - Ingress and service networking - Observability plumbing - Deployment topology **Fluxzero application** **Product behavior** **fluxzero cloud** - State & history - Message delivery - Search - Policy enforcement - Replay & recovery - Observability - Runtime routing - Deployment & scale ### Everything your product needs to run. Built into Fluxzero, instead of assembled separately for every product. #### Model State / history / relationships / search #### Interaction Commands / events / queries / HTTP & WebSocket / schedules #### Policy Validation / authorization / invariants / data protection #### Cloud Cross-app routing / ordering / concurrency / recovery / observability / scale [Explore the technical foundation](https://fluxzero.io/technical-foundation) ### Let your agent build the product. Fluxzero keeps infrastructure out of the application, so your agent can focus on what the product should do. #### The product stays visible The application describes the product in its own terms, not through technical layers. #### A complete history Every interaction keeps its context, so you can trace what caused a problem. #### Fix and replay After a fix, affected work can be replayed without rebuilding the application around it. #### Test the behavior Your agent can prove what a change does without setting up infrastructure first. ### The code describes the product. Your product’s behavior stays visible in the application. Fluxzero keeps the infrastructure out of the way. **Task** Java ```java @Model record Task( @EntityId TaskId taskId, TaskDetails details, @With boolean completed) {} record CompleteTask(TaskId taskId) { @AssertLegal void assertOpen(Task task) { if (task.completed()) { throw TaskErrors.alreadyCompleted; } } @Apply Task apply(Task task) { return task.withCompleted(true); } } ``` **CompleteTaskTest** Test ```java @Test void completeEmitsEvent() { testFixture.givenCommands( "create-task.json") .whenCommand( "complete-task.json") .expectEvents( "complete-task.json"); } ``` [See what code looks like when only the product remains](https://fluxzero.io/product-code) ### See what your application is responsible for. With other clouds, your application includes the product and the infrastructure around it. With Fluxzero, it contains only the product. | Responsibility | Other clouds — Supabase + Vercel, Railway and similar clouds | Fluxzero — The product cloud | | --- | --- | --- | | Application architecture | Product behavior plus services, adapters and infrastructure architecture | Product behavior only | | State and history | You design schemas, queries and transaction boundaries; state is stored as current snapshots unless you build history | Model state, relationships and complete history are built in | | Coordination | App code owns routing, concurrency, ordering and cross-service coordination | The cloud routes, orders and coordinates every interaction | | Failure and recovery | You build retries and recovery paths; crashes can still lose in-flight work | Durable delivery, replay and recovery are built into the cloud | | Ingress and networking | You assemble and secure gateways, proxies, service networking and discovery | One secured application boundary, handled by the cloud | | Scale and operations | Configure, connect, scale, monitor and operate every component and service | Distribution, backpressure, observability and scale are automatic | ### Fluxzero improves. Every product benefits. Every improvement to Fluxzero reaches your product automatically. You do not have to rebuild or migrate it. **fluxzero** Shared cloud runtime Continuously improved - Performance - Hardening - Operational insight - Recovery Inherited automatically Every product ### When to choose Fluxzero. Choose Fluxzero when you want to build the product, not the platform required to run it. #### Fluxzero For builders who want to focus on product features and expect the technology underneath to just work. #### A component cloud For engineering teams that want full control over how their infrastructure is designed and operated, from service topology to capacity planning and failure recovery. ### Build what matters. Let the cloud carry the rest. [Get started](https://fluxzero.io/get-started) [Explore the technical model](https://fluxzero.io/docs) --- # Product decisions are the code — Fluxzero Source: https://fluxzero.io/product-code/ [Back](https://fluxzero.io/how-it-works#behavior-title) Product code ## Product decisions are the code. When the cloud handles the engineering underneath, a feature can be just its business rules and follow-up actions. These examples show what that leaves your agent to write. You build in natural language. Fluxzero chose Java for the code underneath: a proven backend language that agents speak fluently. Your code remains easy to extend as your product grows. 01 · Making changes ### Only product logic. Working at any scale. You decide how a feature should work. Fluxzero keeps its rules intact when many customers act at once. The same logic continues to work as usage grows, without engineering work for your agent. **ReserveTicket.java** One rule, two changes ```java record ReserveTicket( @NotNull ReservationId reservationId, @NotNull TicketId ticketId) { @AssertLegal void assertAvailable(Ticket ticket) { if (ticket.status() != AVAILABLE) { throw TicketErrors.notAvailable; } } @Apply Ticket reserve(Ticket ticket) { return ticket.withStatus(RESERVED); } @Apply Reservation createReservation(User user) { return Reservation.awaitingPayment( reservationId, ticketId, user.id()); } } ``` - **State loads automatically:** Fluxzero provides the product state and which customer is making the change. - **Everything changes together:** If something changes while the rule runs, Fluxzero runs it again before saving. - **Many people, one safe result:** Each decision is kept correct even when many customers act at once. 02 · Keeping track ### Your product changes. Its history stays. Define the parts of your product and how they fit together. Fluxzero keeps the information up to date and preserves its history. Your app can use that history directly in its features. **Show.java** Root model ```java @Model record Show( @EntityId ShowId showId, String name, ShowStatus status) {} ``` **Ticket.java** Child of Show ```java @Model record Ticket( @EntityId TicketId ticketId, @Parent(pathInParent = "tickets") ShowId showId, TicketDetails details, @With TicketStatus status) {} ``` **Reservation.java** Child of Ticket ```java @Model record Reservation( @EntityId ReservationId reservationId, @Parent(pathInParent = "reservations") TicketId ticketId, String customerId, @With ReservationStatus status, @With @ProtectData String contactEmail) {} ``` - **Keep track of everything:** Fluxzero keeps track of every part of the product and how it relates to the rest. - **Stored automatically:** Fluxzero loads and saves the information without storage work in the application. - **History preserved:** Fluxzero keeps every previous state of the product available. 03 · Testing behavior ### Know it works. Before customers use it. Your agent tests that features keep working as you build. That includes the edge cases. Fluxzero runs the same product code and rules in tests as in production, so you can ship with confidence. **ReserveTicketTest.java** Behavior test with JSON ```java @Test void reservesAnAvailableTicket() { fixture .whenCommandByUser("customer-42", "/ticketing/reserve-ticket.json") .expectEvents( "/ticketing/reserve-ticket.json"); } @Test void rejectsASecondReservation() { fixture .givenCommandsByUser("customer-42", "/ticketing/reserve-ticket.json") .whenCommandByUser("customer-77", "/ticketing/reserve-ticket.json") .expectExceptionalResult(TicketErrors.notAvailable) .expectNoEvents(); } ``` - **Production behavior:** Fluxzero runs the scenario through the same rules as the real application. - **Real circumstances:** Fluxzero supplies the person and moment described by the test. - **Visible outcome:** Fluxzero confirms success or the expected rejection. No infrastructure or mocks needed. 04 · Finding information ### Your data comes ready to search. Query your data from anywhere in your code. Use a dedicated query class to define what to fetch and who may access it. Fluxzero keeps your data and its relationships searchable as the product changes, without a separate search system to build or maintain. **FindAvailableTickets.java** Query and search ```java record FindAvailableTickets( @NotNull ShowId showId, @NotBlank String section) { @HandleQuery List handle() { return Fluxzero.search(Ticket.class) .whereParent(showId) .match(AVAILABLE, "status") .match(section, "details/section") .sortBy("details/row") .fetch(50); } } ``` - **Search maintained automatically:** Fluxzero updates the searchable data as your product changes. - **Relationships already known:** Fluxzero follows the connections in your product data to find what belongs together. - **Work done in the cloud:** Fluxzero filters and sorts the data. Your code receives the results it asked for. 05 · Set a schedule ### Your product follows up. Even after a restart. Scheduling is part of almost every application. Fluxzero makes it easy to schedule and test what should happen later. Scheduled work survives restarts and deployments, with your rules checked when it runs. **ReservationTimers.java** Start and cancel a deadline ```java @Component class ReservationTimers { @HandleEvent void start(ReserveTicket event) { Fluxzero.scheduleCommand( new ExpireReservation(event.reservationId()), ScheduleId.of("expire", event.reservationId()), Duration.ofMinutes(15)); } @HandleEvent void stop(ConfirmReservation event) { Fluxzero.cancelSchedule( ScheduleId.of("expire", event.reservationId())); } } ``` **ExpireReservation.java** Remove hold and release ticket ```java record ExpireReservation(@NotNull ReservationId reservationId) { @AssertLegal void assertAwaitingPayment(Reservation reservation) { if (reservation.status() != AWAITING_PAYMENT) { throw ReservationErrors.notAwaitingPayment; } } @Apply Reservation remove(Reservation reservation) { return null; } @Apply Ticket release(Ticket ticket) { return ticket.withStatus(AVAILABLE); } } ``` - **Scheduled work preserved:** Fluxzero retains the action through application restarts and deployments. - **Current rules checked:** Fluxzero loads the latest data and checks whether the scheduled change is still allowed. - **Cancellation handled:** Your code names the follow-up to cancel. Fluxzero removes it from the schedule. 06 · Run a workflow ### Workflows pick up where they left off. Some workflows need to wait for an external service before continuing. Define what happens when the response arrives. Fluxzero preserves progress and connects each response to the right process, even after a restart. **PaymentProcess.java** Wait for a payment response ```java @Stateful record PaymentProcess( @EntityId ReservationId reservationId, @Association String pspReference) { @HandleEvent static PaymentProcess start(PaymentStarted event) { return new PaymentProcess( event.reservationId(), event.pspReference()); } @HandleEvent PaymentProcess complete(PaymentSucceeded event) { Fluxzero.sendCommandAndWait( new ConfirmReservation(reservationId)); return null; } } ``` - **Progress preserved:** Fluxzero remembers where each workflow left off, including after a restart. - **Responses connected:** The reference on an incoming response connects it to the right waiting process. - **Ready to continue:** Fluxzero loads that process and runs the next step with its saved state. 07 · Access and privacy ### You decide who may do what. Fluxzero enforces it. Define the access rules that fit your product. Fluxzero enforces them before allowing a change. Information marked as private stays protected and can be erased without losing the surrounding history. **UpdateContactEmail.java** Ownership and protected data ```java @RequiresUser record UpdateContactEmail( @NotNull ReservationId reservationId, @NotBlank @Email @ProtectData String contactEmail) { @AssertLegal void assertOwner(Reservation reservation, User user) { if (!reservation.customerId() .equals(user.id())) { throw ReservationErrors.notOwner; } } @Apply Reservation update(Reservation reservation) { return reservation.withContactEmail(contactEmail); } } ``` - **Identity supplied:** Fluxzero gives your rule the authenticated customer making the change. - **Access checked first:** With sign-in required, Fluxzero rejects unauthenticated requests before the feature runs. - **Private data stays erasable:** Fluxzero stores protected values separately, so they can be erased while the surrounding history remains. 08 · Reach in through the web ### Public web endpoints. Private applications. Your web endpoints live in Fluxzero. Your application has no public endpoint of its own and securely pulls requests when it can handle them. This keeps it out of reach of direct network attacks. Excess traffic waits in Fluxzero instead of flooding the application. **ReservationApi.java** Web request to command ```java @Component @Path("/api/reservations") class ReservationApi { @HandlePost ReservationId reserve(@Valid ReservationRequest request) { var reservationId = Fluxzero.generateId( ReservationId.class); Fluxzero.sendCommandAndWait( new ReserveTicket( reservationId, request.ticketId())); return reservationId; } } ``` - **Input checked:** Fluxzero checks the submitted data against your requirements before running the feature. - **Identity carried through:** The feature receives the customer making the request without extra code to pass that identity along. - **Response handled:** Fluxzero sends the result back to the interface and turns errors into the appropriate web response. 09 · Connect your features ### The same code. Wherever the work runs. Send a request without choosing which application will handle it. Fluxzero delivers it and returns the result. Whether the handler runs in your own app or another one, the calling code stays the same. **TicketApi.java** Requests without routing code ```java @Component @Path("/api/tickets") class TicketApi { @HandleGet List available( @QueryParam ShowId showId, @QueryParam String section) { return Fluxzero.queryAndWait( new FindAvailableTickets(showId, section)); } } ``` - **Web handlers anywhere:** The web handler can run in any connected application. The public endpoint stays the same. - **Queries across applications:** The query handler can run alongside it or in another app. The call stays the same. - **One request, more uses:** Other apps can observe the same web request for analytics while the endpoint handler returns the response. 10 · Scale independently ### Each part can scale independently. Not every part of your application is equally busy. With separate consumers, parts run and scale independently. Fluxzero keeps their progress separate and distributes the work, so capacity can grow where it is needed. **FraudDetection.java** Fraud checks with their own capacity ```java @Component @Consumer(name = "fraud-detection", threads = 4) class FraudDetection { @HandleEvent void check(ConfirmReservation event) { FraudAssessment assessment = Fluxzero.queryAndWait( new CheckForFraud(event.reservationId())); if (assessment.requiresReview()) { Fluxzero.sendAndForgetCommand( new ReviewReservation( event.reservationId(), assessment)); } } } ``` - **Capacity where it counts:** Give demanding work its own consumer. Add threads or app instances as demand grows. - **Independent progress:** Each consumer keeps its own place. Slower work does not hold up other consumers. - **Work shared automatically:** Fluxzero distributes the work across instances of the same consumer. 11 · Using the past ### New features can be built from historical data. Fluxzero preserves your product’s history. Use it to add features retroactively, with the information as it was at the time. The same code processes earlier activity and continues with new activity. **CustomerRewards.java** Retroactive event handler ```java @Component @Consumer(name = "customer-rewards", minIndex = 0) class CustomerRewards { @HandleEvent void reward( ConfirmReservation event, Reservation reservation) { Fluxzero.assertAndApply(new GrantReward( event.reservationId(), reservation.customerId(), 100)); } } ``` - **History supplied:** Fluxzero feeds recorded activity to the new feature from the point you choose. - **Earlier state reconstructed:** Fluxzero supplies the data as it was then, without your code having to rebuild it. - **Progress remembered:** Fluxzero tracks how far the feature has processed and resumes after interruptions. The result ### Your product is the entire application. Your agent writes what the product should do. Fluxzero takes responsibility for making it run. What remains is an application entirely devoted to the product, from the first feature to a fully distributed system. [Start building](https://fluxzero.io/get-started) [Inspect the SDK](https://fluxzero.io/docs) --- # How Fluxzero keeps products running — Fluxzero Source: https://fluxzero.io/technical-foundation/ [Back](https://fluxzero.io/how-it-works#layers-title) Technical foundation ## How Fluxzero keeps products running. Enterprises expect critical systems to keep their promises under pressure. That standard matters long before a product reaches enterprise size. With Fluxzero, it is built into every product from day zero. 01 · Foundation by default ### Every cluster comes with the full Fluxzero foundation. A cluster is a dedicated environment containing a product’s applications, data, and technical foundation. Every cluster is isolated from every other cluster, and its applications stay off the public internet. From the first deployment, its foundation provides correctness, security, privacy, recovery, auditability, and controlled scale. These guarantees are built into every cluster—not added later by the product team. **External traffic** Your product cluster **Application A** 3 tasks **Application B** 2 tasks **Fluxzero foundation** Correctness Security Privacy Recovery Auditability Scale Every cluster isolates one product and includes the complete Fluxzero foundation from its first deployment. 02 · Correctness ### Every action leaves the product in a valid state. Your product defines what must always be true. Fluxzero makes sure those rules still hold when many users act at the same time. A change either succeeds completely or leaves nothing half-finished behind. - 1 **Buyer A** **Ticket 42** Available **Reserved** - 2 **Buyer B** **Ticket 42** Already reserved **Rejected** Buyer A acts first and reserves ticket 42. Buyer B acts second and cannot reserve the same ticket. 03 · Reliability and recovery ### Failure does not mean lost work. Fluxzero records work before your application starts it. If an instance restarts, the work waits and continues when it is ready. One failing part does not stop the rest of the product. Fix the cause, then replay only the affected work. Failed work remains visible and recoverable without first building a separate recovery system. Received Recorded Handled Recorded first. Handled when the application is ready. - 1 - 2 - Failed - 4 - 5 Fix Replay Repair the cause. Replay the affected range. 04 · Privacy and data control ### Keep the history. Remove the personal data. Sensitive values stay separate from the durable history. Trusted code can use them without exposing them in logs, and they can be permanently erased without destroying the surrounding record. Fluxzero protects PII data and makes it erasable while you decide how it is used. Each recipient sees only the data the product allows. These controls make data minimization and erasure practical and support requirements under GDPR in Europe and California’s CCPA. **Order 42** size M email Erase **Order 42** size M redacted The protected email is erased while the rest of order 42 remains available. 05 · Secure by design ### Your applications stay off the public internet. Fluxzero receives public web traffic at its managed edge. Your applications pull incoming traffic and send outbound traffic over connections they open themselves, so none of them needs a public endpoint. Your applications still decide who someone is, what they may do, and whether a request is valid. Fluxzero gives every request a protected path to those product decisions. **Public internet** **Fluxzero foundation** Traffic in and out **Applications pull and send** Outbound connections Your cluster **Application A** No public endpoint **Application B** No public endpoint Fluxzero receives public traffic while applications stay private and pull and send traffic over connections they open themselves. 06 · Auditability ### If it is not in the audit trail, it did not happen. Fluxzero records every request and response, together with every internal message and interaction that followed. Their connection is preserved from the first cause to the final outcome. The dashboard makes that history searchable from beginning to end. It shows what happened, where progress stopped, and which part of the product was affected. The complete operational view is available without setup. Current state tells you what is true. The audit trail tells you why—and everything that happened along the way. **Ticket reservation · #42** - 09:41:02.103 Request Reserve ticket - 09:41:02.114 Event Ticket reserved - 09:41:02.119 Response Reservation confirmed **Fluxzero dashboard** Available without setup **Audit trail** Every interaction **Traces** Cause to outcome **Issues** Occurrences and versions **Application graph** Flow and performance A ticket reservation can be followed through each connected message in the Fluxzero dashboard. 07 · Bounded traffic ### Traffic spikes don’t overwhelm your applications. Fluxzero limits how much work reaches each application at once. Excess demand waits outside instead of flooding it, so DDoS-like overload cannot cascade through the product. **Bounded capacity** Application Held back Excess demand stays outside the application. 08 · Independent scale ### Each part of the product scales independently. Slow work cannot stall the rest of the product. Capacity grows exactly where it is needed. Start as one application, then split it into separate services—or bring it together again—without changing what the product does. Recorded events **Ticketing** **Payments** **Notifications** Independent progress keeps slow work isolated. **One application** same product behavior **Independent services** 09 · Safe evolution ### New capabilities can reach into the product’s past. Your product can change without abandoning the data and decisions it has already recorded. Older information remains usable by the current application, even as the product evolves. Add a new capability later and run it across existing history. It can work retroactively instead of starting empty on the day it is introduced. **Audit trail** The complete product history Event **Ticket reserved** Event **Payment received** Event **Reservation confirmed** Every capability can use the full history Already running **Ticket reservations** **Payment processing** **Customer confirmations** **Cancellation handling** Added later **Customer rewards** Built from all previous purchases Ticket reservations, payment processing, customer confirmations, cancellation handling, and customer rewards can all use the complete product history. 10 · ZeroOps cloud ### Launch with production-grade operations already in place. Deploy to as many clusters as your products require. Fluxzero operates every one from its first deployment, with point-in-time recovery backed by automated backups and a complete monitoring view available as soon as it starts. Create a new cluster or duplicate one from an earlier point in time. Each cluster can be paused without losing its identity or state, while access and secrets remain protected. **Production** Cluster **Acceptance** Cluster **Built into every cluster** - **Deploy** Start a new cluster - **Pause and resume** Preserve identity and state - **Point-in-time recovery** Automated backups; restore or duplicate - **Protected access** Secrets stay encrypted **Monitoring in every cluster** - **Audit trail** Every message and interaction - **Application logs** Search all application output - **Traces and issues** Follow causes and failures - **Insights and visualizations** Performance and trends Production and acceptance clusters share the same operated lifecycle, point-in-time recovery backed by automated backups, and complete monitoring view. 11 · A shared foundation ### The foundation keeps improving underneath every product. Every Fluxzero product runs on the same hardened foundation. When that foundation becomes stronger, every product benefits without taking on more infrastructure code. Your application remains the product itself. It does not become a permanent record of every technical decision made on the way to launch. **Your product** Behavior, rules, experience **Fluxzero foundation** Correctness Security Privacy Recovery Auditability Scale Continuously improved by the cloud From day zero ### Enterprise-grade guarantees. Democratized. On an infrastructure cloud, you are responsible for these guarantees in every product. With Fluxzero, they are properties of the cloud. **Build the product. Skip everything else.** [Start building](https://fluxzero.io/get-started) [Inspect the technical docs](https://fluxzero.io/docs/guides) --- # Fluxzero Pricing — Build free. Launch, then run. Source: https://fluxzero.io/pricing/ Fluxzero pricing ## Choose your plan Build your entire app for free, then launch it. Scale your product as you grow, without changing foundations. Free #### Builder € **0** Build your entire app before you pay. [Get started](https://fluxzero.io/get-started) - Use Claude Code, Codex or other agent - **Local runtime** - Local logs - Community support Launch #### Starter € **49** per week or €190 per month Start running in production. [Request launch access](https://fluxzero.io/contact) - Includes a fully-featured environment: - **Starter cluster included** - **Starter app included** - 100GB storage included - Auth included (max 100 users) - 1 custom domain - Audit trail - Slack support Grow #### Startup € **490** per month For products gaining traction. [Request startup plan](https://fluxzero.io/contact) - **Small cluster included** - **2 small apps included** - 200GB storage included [1] - 1000 users included - 7 days backup [1] - Unlimited domains - Audit trail - Ticket support Scale #### Scale Up € **890** per month For products that need more capacity. [Request scale up plan](https://fluxzero.io/contact) - **Medium cluster included** - **2 medium apps included** - Unlimited clusters & apps [1] - 400GB storage included [1] - Unlimited users included - Unlimited backups [1] - Unlimited domains - SSO - 99.9% uptime target - Optional static IPs - Audit trail & insights - Priority support Calculate extra capacity Customize #### Enterprise **Custom** pricing Dedicated setup for larger teams. [Contact us](https://fluxzero.io/contact) - **Custom workloads** - Additional sizes - Custom storage - Custom backup policy - Custom SLAs - Private Slack channel - Unshared hardware optional - Unlimited domains - Audit trail & insights - 24/7 support [1] Extra clusters, apps, backup storage, and storage above the included amount are measured during the month and settled at month-end. ### Included in every paid plan The limits change by plan, but the production foundation stays the same. #### Hosting & runtime - App and frontend hosting - Secure web gateways - Automatic load balancing - App and frontend scaling #### Data & messaging - Data stores - Search - Durable message logs - Seamless inter-app communication #### Visibility - Searchable audit trails - Request traces - Contextual errors - Full visibility into your apps #### Access & isolation - Auth - Role-based access - Fully isolated app components ### Frequently asked questions #### What are clusters and apps? A cluster is the managed environment your app runs on. An app is one running application inside that environment. Starter capacity gets you online quickly; Scale Up lets you add more clusters and apps when your product needs more room. #### When will I be billed? You can build locally for free. Billing starts when you activate a paid plan for an app. Your billing schedule starts on the day your first payment is made. Starter is billed every 7 days; Startup and Scale Up are billed monthly unless agreed otherwise. Extra or larger clusters and apps, and storage above the included amount, are measured during the month and billed at the end of the month. #### Why can I pay weekly for Starter? The weekly Starter option is there so you can experiment with a real Fluxzero cluster for a short period without committing to a full month. It is not meant as a discounted version of the monthly plan. It gives builders a low-friction way to try a live production foundation, validate an idea, or test launch readiness before choosing a longer-running plan. #### Is sales tax included? Prices are shown excluding sales tax, VAT, and similar taxes unless stated otherwise. Any required tax may be added during billing based on your billing details and local rules. #### What capacity is included, and can I cap my bill? Every paid plan includes fixed cluster, app, and storage capacity as shown on the plan card. That included capacity is part of the plan price. From Scale Up, you decide which extra clusters, apps, storage, or options are added before they affect your bill. Fluxzero is designed to make usage visible before it becomes a surprise. #### Will prices change in the future? Pricing may evolve as Fluxzero grows and the platform changes. If a price change affects an active paid plan, we will communicate it before it applies. #### What happens if I cancel or pause my plan? Your app will stop running on the paid plan after cancellation takes effect. In many cases you can stop runtime capacity when an app is not actively running. If you need to pause while keeping data or configuration, contact support and we will help choose the safest option. #### What happens if my payment fails? We will notify you and give you time to fix the payment method. If payment remains unresolved, paid runtime access may be paused until billing is restored. #### What if I need development, test, or staging environments? Additional clusters for development, test, staging, or preview environments can be added from Scale Up. We can help you choose the right size and setup. #### What if I need more scale or higher availability? Scale Up supports additional clusters and apps and includes a 99.9% uptime target. Enterprise adds custom workloads, additional sizes, private hardware, custom SLAs, and dedicated operational support. Fluxzero currently runs from Europe, with more regions planned. #### What happens if I go over included limits? Extra or larger clusters and apps can be added from Scale Up. These are measured during the month and billed at the end of the month. If your data volume exceeds included storage, additional storage is billed at €0.0048 per GB per day. Our fair use limits are designed to cover typical application traffic for most products. If your application generates unusually high public network traffic, we may temporarily limit traffic, request changes, or move you to a suitable plan. Still wondering? [Get in touch](https://fluxzero.io/contact) and we'll help. --- # About Fluxzero - Origin story Source: https://fluxzero.io/about/ Origin story ## Fluxzero started with a simple frustration. Building software kept drifting away from the product itself. The first time we tried to build a serious product, we thought the hard part would be the idea, the users, and the product itself. Instead, we got buried in everything around it. ### The work around the product kept taking over Again and again, we saw the same thing happen. A team would start with a clear product idea, then slowly disappear into the foundation beneath it: auth, data, architecture, permissions, deployment, operations, monitoring, failures, security, scale. None of that work is optional. It is the work that makes software trustworthy. But it is also the work that turns a product into an infrastructure project before anyone even gets to use it. We did not want another workaround. We wanted the foundation we wished had existed from the start. ### Then AI changed who could build AI made it possible for founders, designers, frontenders, domain experts, and small teams to build working software at a speed that used to be impossible. That is exciting. But it also exposes the same old problem in a sharper way. It makes little sense for AI to rebuild the foundation every time it builds a product. And it's risky too: builders are left trusting technical choices while trying to build the product itself. ### So we made our foundation reusable That is why we turned the foundation we had built into something every product could share. Fluxzero lets AI focus on the product while we keep improving the security, reliability, recovery, and scale underneath. We are a European team with deep backend and distributed-systems expertise. For years, we built and grew enterprise cloud products that could not afford to fail. Correctness, security, reliability, testing, operations, and scale mattered from day one. Fluxzero grew out of that work. Our obsession is simple: keep making that foundation better, while keeping it out of the product layer so it never slows builders down. What this means now ### Every builder can start on a real foundation Fluxzero gives anyone building with AI a reliable backend from day zero. You focus on the product. Fluxzero handles the architecture underneath, so what you build can become real software. [Get started →](https://fluxzero.io/get-started) --- # Start building with Fluxzero Source: https://fluxzero.io/get-started/ ## Start building with Fluxzero. Just copy this into your agent. ``` Build my app with Fluxzero. Start at plugins.fluxzero.io ``` Works with - [Claude Code](https://claude.com/product/claude-code) - [Codex](https://openai.com/codex/) - [Cursor](https://cursor.com/) - [Gemini CLI](https://github.com/google-gemini/gemini-cli) - [GitHub Copilot](https://github.com/features/copilot) --- # Contact Fluxzero Source: https://fluxzero.io/contact/ Contact ## Get in touch Questions about Fluxzero, pricing, partnerships, or something else? We’d love to hear from you. ### Send us a note A few lines are enough. We’ll take it from there. Full name Email address Message Send Office Wilhelminakade 81 3072 AP Rotterdam The Netherlands - **Building:** Maastoren, 33rd floor - **Member of the press?:** Send us a note [here](mailto:press@fluxzero.io). - **Careers:** Introduce yourself [here](mailto:careers@fluxzero.io). Messages are read by the people building Fluxzero.