Fast to build. Fast to run. Hard to break.
Every custom project rebuilds the same plumbing. Archestack ships it as generic building blocks - sign-in, data, screens, events, deployment - built once, tuned once, hardened once. We, or your developers, assemble them into the ERP, WMS, CRM or internal tools your operation actually needs. In days, not months.
The problem
Custom software is slow.
Slow to build, slow to run, slow to make safe.
Every bespoke project starts from zero: sign-in, permissions, data access, audit trail, deployment. Months pass before the first screen a user cares about, the code is fresh and untested, and the security review is whatever the deadline left room for. Archestack starts from building blocks that were finished before your project began.
- Months of plumbing before the first useful screen
- Performance tuned per project, if there is time
- Sign-in, permissions and audit re-invented every time
- Security reviewed once, by whoever was free that week
- Generic blocks for sign-in, entities, pages, events and deploys, already built
- Tuned once against real workloads, real-time everywhere
- One login, one permission model, one audit trail, shared by every app
- Hardened across every deployment, not just yours
- Working software in days, not quarters
- Screens that update live, without a refresh
- A security model that arrived already reviewed
- Your team's time on workflows, not scaffolding
The whole stack, on one dashboard.
Tables, business entities, pages, event triggers, scripts, scheduled jobs - all of it, on one home screen. Every one of them is a generic block that existed on day one, so the first hour of a project goes into modelling your business, not installing plumbing.
Every run, every error, with the stack trace.
Scheduled jobs and event triggers leave a full log: what fired, when, what it touched, and if it broke, the exception with the line number. No black box, no "open a ticket to see why your nightly sync failed".
How it works
Build it once.
Run it forever.
Model your business
Define tables, fields, and relationships in a visual schema designer. It compiles straight to PostgreSQL. Your database, no proprietary storage layer.
Wire your logic
Business rules and event triggers run on Roslyn-scripted C#. Reusable script modules, real types, real debugging. No DSL to learn or fight.
Build your screens
Drop fields onto a page or write custom React when you need to. Both render through the same runtime, so your team picks the right tool per screen.
Ship it
One-click schema deployments, full audit trail, packaged config-as-code. Promote between environments with confidence, and a rollback if you need it.
Model your business
Define tables, fields, and relationships in a visual schema designer. It compiles straight to PostgreSQL. Your database, no proprietary storage layer.
Wire your logic
Business rules and event triggers run on Roslyn-scripted C#. Reusable script modules, real types, real debugging. No DSL to learn or fight.
Build your screens
Drop fields onto a page or write custom React when you need to. Both render through the same runtime, so your team picks the right tool per screen.
Ship it
One-click schema deployments, full audit trail, packaged config-as-code. Promote between environments with confidence, and a rollback if you need it.
Why it's fast
Generic building blocks.
That's the whole trick.
A custom project spends most of its months on things nobody asked for: sign-in, permissions, data access, audit, deployment. Archestack ships those as generic building blocks, the same ones under every app we run. What's left is assembly, and assembly takes days.
Generic is also why it runs fast. One entity engine, one real-time channel, one query layer, tuned once against real workloads and shared by every customer. A performance fix made for one deployment lands in all of them.
And it's why it's secure. One login, one permission model, one audit trail, hardened continuously instead of re-invented per project. Your app inherits the security every other app on the platform already runs on.
Backups on your schedule. Restore is a button.
Backups run on the cadence you set and land where you say. Restore is a button, not a support ticket. The same backup block runs under every deployment on the platform, which is why it has been exercised more often than any custom-written one ever will be.
One login for every app you build.
Sign-in, sessions, password policy, invitations: a generic block, shared by every app on the platform. Add as many users as your operation actually has. The auth was there before the first screen was.
One permission model. Reviewed once, enforced everywhere.
Define roles like owner, editor, or whatever your operation calls them, describe what each may do, attach people. Every page, entity and API on the platform enforces the same model, so a permission bug fixed for one customer is fixed for all of them.
Real C# where you need it. A block around everything else.
Validations, calculations, side-effects, integrations - written directly in the event trigger as real C#, with full types and the same runtime the screens use. You write the rule. The block around it handles the transaction, the audit trail and the permission check.
Customer story
A 150-person logistics company
replaced their stack with one platform.
A European logistics operator running 150 employees across two warehouses and a planning desk had stitched together a third-party WMS, a separate route planner, a SaaS time-clock, and three spreadsheets nobody wanted to touch.
In one quarter, their internal team rebuilt the whole thing on Archestack. Same workflows, one database, one UI, real-time across handhelds, planning, and back-office.
Reference customer. Name available on request.
Built on Archestack
These are real apps, running every day.
Warehouse, dispatch, invoicing, time tracking. The same platform underneath, the screens shaped to the business on top.
Auto-rotates every 5 seconds. Click any screen to enlarge.
Start a 7-day trial.
See how fast you get there.
Full platform, full access. Your data and configurations are wiped at day 7 unless you upgrade. Explicit, no auto-charge, no surprises.
Pricing that fits
your business.
Every Archestack implementation is different, so the price is too. Tell us what you want to ship, and we'll send a quote that covers exactly what you need.
No public price lists, no sales call before you have something concrete in mind. Tell us what you want to build and the team behind it.
Get a quoteWhy MCP works better here
An AI configures blocks. It doesn't write plumbing.
Connected over MCP, a model doesn't generate a login screen, a data layer or an audit trail for you. Those are generic building blocks that already exist. It configures them and writes only your business logic, so its context holds your rules instead of thousands of lines of repetitive code.
What you can build
One platform. Every system your business runs on.
ERP is where most people start, not where the platform stops. The same foundation runs warehouse systems, CRMs, planning tools, portals and integration layers - one database, one login, one place to change things.
ERP & back office
Orders, invoicing, stock, purchasing, finance. The full back office, modelled to how your business actually runs instead of a vendor template.
Warehouse management
Bin layouts, pick paths, handheld scanner screens, real-time stock. A WMS shaped to your floor, not a floor bent to fit the software.
CRM & sales
Pipelines, contacts, quotes, follow-ups. A CRM that speaks your sales process and shares one database with the rest of the business.
Workflow automation
Approvals, escalations, scheduled jobs, event-driven rules. Replace the manual steps and the spreadsheets nobody wants to own.
Integrations & APIs
REST APIs in and out, webhooks, sync jobs. Connect the tools you keep, and retire the ones you do not.
Internal tools & portals
Dashboards, admin panels, customer and supplier portals. The one-off apps every company needs and no SaaS sells.
If it has a data model and a workflow, it belongs on Archestack.
Two paths
Two ways to build it.
Whether we build it with you or your team takes the wheel, the result is the same: working software in days, on building blocks that were tuned and hardened before you arrived.
Pair with our team.
We design and build the platform around your operations. Because the blocks already exist, you get tailored business software in days instead of months, hosted wherever you want, on a database we hand the keys to. Best for businesses that want results without staffing a development team.
- We model your domain together
- Production-ready in days
- You keep everything when we leave
Hand it to your developers.
Your team gets the full platform: visual schema designer, page builder, C# scripting, REST APIs, deployment tooling. They assemble, the blocks do the plumbing. Best for IT teams modernizing internal systems and consultants delivering bespoke software to their own clients.
- Code-first where it matters, low-code where it pays
- Real PostgreSQL, real .NET, real React. No DSL to learn.
- Ship custom business software in days, not quarters
Both paths start the same way: spin up a 7-day trial and see what the platform feels like. Whether your developers run with it or you'd like us to drive, that conversation comes after.
The building blocks
Everything a business system needs. Built once, shared by every app.
The plumbing every business app rebuilds, already built. Generic on purpose: the same blocks run under every customer, so they are tuned and hardened for all of them at once. Your team's time goes into the workflows that move your numbers.
Schema Designer
Tables, relationships, indexes, constraints, drawn on a canvas and deployed with one click. Real PostgreSQL underneath, with versioned migrations and rollbacks.
Entities & Pages
Define business entities that span multiple tables. Get list and detail pages auto-generated, or write custom React when the screen earns it. Both render through one runtime.
Custom Pages
When the generated UI isn't enough, drop into real TSX. The Code editor sits beside a live "preview as user" pane, so a custom dashboard, planning board, or mobile screen takes shape in front of you - same runtime, same auth.
Business Events
Wire validation, calculations, notifications, integrations. Before or after any create, update, or delete. Real C# scripts, real types, real debugger when something goes wrong.
Scripts & Modules
Reusable script modules in real C#. Call them from event triggers, schedules, or other scripts. Same types, same debugger, no separate scripting language to learn.
Scheduled Events
Cron-style schedules that fire scripts and entity actions at the right time. Nightly reports, hourly syncs, end-of-month rollups - none of it needs a separate job runner.
Document Generation
HTML templates rendered to polished PDFs from the same entities that drive your screens. Invoices, delivery notes, work orders - one source of truth, one click.
Branding
Logo, colours, app name, all configured per deployment. White-label customer-facing apps without forking the platform or asking a CSS engineer to style anything.
Business Units
Run multiple business units side by side, each with its own scoped resources - pages, entities, events, scripts. Dependencies auto-include, so a unit owns a coherent slice of the platform without losing its links.
Packages
Bundle entities, pages, events, scripts, and PDF templates into versioned, importable packages. Install Invoicing in one tenant, Helpdesk in another, your own modules anywhere. Re-use across customers, no fork.
Multi-Language
Localized UI in Dutch, French, German, and English out of the box, plus database-backed translations for your own business data. Add a locale, your whole app speaks it.
Under the hood
Boring tech, sharply assembled.
No proprietary database, no proprietary scripting language, no rented runtime. Stacks your team already knows, composed into something that gets out of your way.
See it move
Less talking. More watching.
Real tools. Real screens. Tap one, watch it work.
Design your data, visually.
Add tables to the canvas, set column data types, mark indexes, draw foreign keys to related tables. Apply the migration with one click.
Wrap a table in a queryable entity.
Pick a master table, choose which columns to expose, join related tables. The live preview pulls real rows from the database as you build.
Forms and grids, generated.
Pick a business entity, the overview grid, detail form, and create dialog appear immediately, ready to drop into navigation.
Customise the front end where it matters.
Edit page layouts, swap generated sections for hand-written TSX components. The escape hatch is always there for the screens that don't fit a standard mould.
Make it look like your company.
Drop in a logo, pick a primary colour, set the app name. The whole UI rebrands instantly. White-label deployments don't need a CSS engineer.
Real-time business logic, in C#.
A script module fires on an entity change, updates a dispatch board, and a second connected screen receives the change live, no refresh.
Talk to anything.
REST APIs, webhooks, dedicated integrations to other databases, custom .NET script modules for the long-tail. One script engine reaches all of them - no middleware sitting between you and the data.
Generate documents from your data.
Author an HTML template, render it to a polished PDF with one call. Invoices, delivery notes, work orders, all driven by the same entities that power the screens.
Ship from the same UI.
Apply schema changes and push entities, pages, and rules to production from the same screen you built them in. No separate build pipeline to babysit.
How we work
Straightforward engagement.
No surprises, no lock-in.
Discovery & a free quote
When you reach out, we schedule a call to map what you actually need. We walk through how it gets implemented and where it gets hosted, make a high-level estimate of the work on our side, and send you a quote. Free of charge.
Build, approve, go live
Once you accept the quote, we start straight away. You get at least a test environment and a production environment, fully isolated from each other, and you approve every change in test before it ships to production.
See what depends on what, before you change it.
The dependency graph maps every entity, page, event, and script. When we change a column or rename a field, we know exactly which screens, rules, and reports light up - and so will you, when you take it over.
The exact SQL that will run. Reviewed, not assumed.
Every deployment shows the generated DDL up-front. No black-box migrations, no surprises in production. Your DBA can sign off on the actual statements, the same way they would on a hand-written script.
Hooks for the work the schema change can't do alone.
Real-world deployments backfill data, flip feature flags, prime caches. The platform runs your pre-deploy and post-deploy scripts inside the same transaction window as the schema change, so a rollout is one atomic step instead of three meetings.
Have a question?
Tell us about it.
Drop us a line about your project, the system you wish you had, or anything you'd like to see in Archestack. We read everything.
Prefer email? Reach us at nick@archestack.eu