Use Cases
Real solutions for problems we've seen teams struggle with for years
Internal Tools That Scale With You
Back-office software that needs to stay flexible as your company grows. Today's simple CRUD app becomes tomorrow's complex workflow engine.
The Problem
You need internal tools fast. Buy vs. build feels like a choice between "doesn't fit" and "takes forever". SaaS tools lock you in, custom development is slow.
The Approach
Start with a generated application that covers 80% of your needs out of the box. Customize the remaining 20% with your specific business logic. As requirements grow, regenerate with new entities and commands. Your customizations stay intact.
Example Tools Built
- Order management
- Customer portals
- Reporting dashboards
- Scheduling systems
- Invoice processing
- Inventory tracking
Why Not Buy?
Off-the-shelf tools work until they don't. When your process doesn't fit their workflow:
- • You adapt your process to the tool
- • You pay for features you don't need
- • You're locked into their roadmap
- • Your data lives in their cloud
Why Not Build From Scratch?
- • Weeks of boilerplate setup
- • Architecture decisions upfront
- • Testing infrastructure needed
- • Deployment pipeline to build
Why Fractal Forge?
Get the speed of buying with the flexibility of building. Production-ready from day one, customizable forever.
Fractal Forge enabled Heaten to keep building while postponing heavy ERP/enterprise platform decisions. After acquisition, the new owner could apply their standard portfolio blueprint without a rewrite.
Architecture Pattern
In production: Flipstream runs exactly this pattern. Their React SaaS frontend integrates with the Fractal API, while the Svelte admin UI handles oversight of all tenants.
The Backend Your SaaS Deserves
Use Fractal Forge as the entire backend layer for your SaaS product. The generated API handles domain logic, auth, RBAC, and multi-tenancy. Your customer-facing UI can be whatever tech you prefer.
The Problem
Building a SaaS means solving the same backend problems everyone else has solved: authentication, authorization, multi-tenancy, audit trails, admin tooling. This is months of work before you write a single line of product-specific code.
The Approach
The Fractal-generated FastAPI becomes your API layer. The generated SvelteKit UI becomes your admin console for managing accounts, users, and operations. Your customer-facing frontend (React, Vue, mobile, or whatever you prefer) talks to the Fractal API. The customer never sees the admin UI.
What Fractal Handles
- Authentication & tokens
- Role-based access control
- Multi-tenancy
- Audit trails
- Domain logic & events
- Admin operations UI
Flipstream migrated databases and moved from cloud to on-prem within days, because Fractal's core isolates infrastructure behind adapters and interfaces.
Modernize Alongside, Not Instead
The "big bang rewrite" fails more often than it succeeds. Requirements change mid-project, knowledge gets lost, and teams burn out. Fractal Forge enables incremental modernization.
The Problem
You have a legacy system that works but is painful to maintain. Fat controllers, business logic scattered across the codebase, no tests, and every change risks breaking something.
The Approach
Build the new system alongside the old one. Model a clean domain in Fractal Studio, generate a new codebase with proper architecture, and migrate functionality piece by piece. Both systems can run in parallel during the transition.
The Outcome
- Lower risk: old system stays available as fallback
- Faster delivery: value delivered incrementally
- Clean slate: new architecture without legacy baggage
Migration Timeline
Common Excel Problems
- "Which version is current?"
- "Who changed this formula?"
- "It worked yesterday!"
- "Only Sarah knows how this works"
After Fractal Forge
- Single source of truth
- Full audit trail
- Access control
- Documented logic
Free Business Logic From Spreadsheets
Every company has that spreadsheet. The one with critical business logic, managed by one person, emailed around as "final_v3_FINAL.xlsx". It's a ticking time bomb.
The Problem
Business-critical processes trapped in Excel files. No version control, no access control, no audit trail. When the spreadsheet expert leaves, so does institutional knowledge.
The Approach
Extract the business logic into a proper application. Model the entities and rules in Fractal Studio, generate a web application with forms and workflows, and import the existing data. Users get a familiar interface with professional-grade reliability.
The Outcome
A proper application with multi-user support, role-based access, and a complete audit trail. The business logic is documented in code, testable, and maintainable.
Prototypes That Don't Become Debt
Most prototypes are hacked together fast, then either thrown away or become unmaintainable production code. Fractal Forge gives you both: rapid iteration and production quality.
The Problem
You need to validate an idea fast. Traditional prototyping means cutting corners on architecture, testing, and deployment. If the idea works, you're stuck with technical debt from day one.
The Approach
Model your concept in Fractal Studio, generate a working application, and demo to stakeholders, all within days. The generated code follows best practices, so when the prototype gets approved, you're already running production-quality code.
The Outcome
- Validate ideas fast with real, working software
- No "prototype tax" when moving to production
- Iterate with regeneration as requirements evolve
From Demo to Production
Key difference: The prototype is the production app. No throw-away code, no rewrites.
Example: Django View
Import the Fractal-generated business layer into your Django project. Your views stay thin while domain logic remains centralized.
Domain Logic as a Library
Sometimes you don't need the full stack. The Fractal libraries can be imported as Python packages into existing projects or adjacent systems.
The Problem
You have an existing Django, Flask, or other Python project. You want Fractal's domain architecture without replacing your entire stack.
The Approach
Import the Fractal-generated business layer as a Python package. Your existing project gets entity services, repositories, and event systems without duplicating business logic or rewriting everything.
Example Integrations
- Django applications
- Dagster pipelines
- Reporting APIs
- Data analytics tools
Built a ticket ordering system for several museums: shopping basket, checkout, payments, ticket downloads, and order administration. Fractal's domain layer kept Django views thin, business logic centralized, and everything easily testable.
Your LLM Integration Works. Now Ship It.
You've got your prompts dialed in and the AI doing what you want. But turning that into a real product means auth, users, billing, and all the boring stuff. That's where we come in.
The Problem
Building with LLMs is fast. Building everything around them isn't. User accounts, API keys, usage limits, payment integration, admin tools. Suddenly your weekend project needs months of infrastructure work.
The Approach
Generate a production-ready backend with Fractal Forge. Wrap your LLM calls in a service adapter. Your AI endpoints automatically get authentication, rate limiting, usage tracking, and an admin dashboard. Keep iterating on prompts, not plumbing.
The Outcome
- Ship your AI product in days, not months
- Clean, maintainable code you actually understand
- Focus on what makes your product unique
What You Get
- User auth & API keys out of the box
- Request logging & token tracking
- Usage limits & billing hooks
- Admin dashboard for operations
- Multi-tenant from the start
Keep vibing. Fractal handles the infrastructure so you can keep iterating on what matters.
Have a similar challenge?
Let's discuss how Fractal Forge can help with your specific situation.