Build enterprise integrations in hours, not weeks

More than integrations. The AI writes the plan and builds the integration with its data mappings, but it also assembles monitoring views and alerts, builds apps in the app builder, and — when asked — investigates what went wrong in a run and why. In practice it can be asked to do the same work on the platform that a user would do by hand: a person describes the need, reviews the result and decides what goes to production.

Yes, and you choose how. In review mode every change is shown as a diff before it is written, and a background implementation run produces a proposal that is not written into the integration until someone approves it. Everything the AI writes goes into version control, so it can be inspected and undone afterwards.

A mistake does not reach production unnoticed. The implementation is validated and security-checked while it is being built, tests are run, and deployment is always a separate human decision. If something still goes wrong, rolling back to the last working version is one action.

Only if you decide so. You choose the model, and the whole platform can run against a local model, in which case nothing leaves your environment. When an external model is used, a prompt gateway can additionally inspect the traffic and block content matching your rules before it is sent.

Yes. AI traffic can be restricted geographically — to the EU/EEA, for example: the model selection shows where the data centre serving each model sits, and only models meeting your requirement can be allowed. At the strictest setting the model runs inside your own environment, so no traffic leaves it at all.

Yes. FastHub supports both your own model credentials and models run locally. Keys stay server-side: integrations and agents call the model through a proxy and never hold a key themselves.

Yes. Each integration carries its own rules for what the AI may do to it — auto-approval can be forbidden outright, for example. The rules are enforced server-side on every write and cannot be talked around by prompting the AI.

The implementation work itself is largely automated: the AI writes the integration, maps the fields and scaffolds the tests. People are still needed for the work around it — which systems to connect and in what order, what the data means for the business, what has to happen when something goes wrong, and when a change is released. Those are decisions, not typing. Everything can also be done by hand without the AI.

Practically anything with an interface: REST and SOAP services, databases, SFTP and files, message queues, cloud services and SaaS systems. There are hundreds of connectors, because the platform is built on open-source Apache Camel and its whole connector library is available as it is.

Integrations are built on open-source Apache Camel, packaged as containers and run on Kubernetes. That is widely used standard technology rather than a closed FastHub-only format — the skills to work on them are not ours alone.

Yes, at any point. The flowchart is a view onto the source file: the same integration can be edited visually or written directly as code. The project's files are in the editor and in version control, so nothing is locked away inside the tool.

With a visual mapper: source fields are wired to target fields through functions, constants and lookup tables, and test cases are written against the mapping. The mapping runs as it is inside the integration, so what you see in the editor is what executes at runtime.

You write test scenarios for an integration that assert both the end result and which steps ran. A single step can be given a canned response so no external system is needed, and the whole integration can be run against a development environment with the result painted straight onto the flowchart.

Yes. The API Gateway publishes an integration's interface to partners in its own network zone, with per-partner keys, quotas, IP allow lists and rate limits. An external caller never reaches the platform directly.

An app builder on the same platform: internal apps, portals, forms and views onto integration data without a separate frontend project. The same visual data mapper is used there too, so what you learn once carries over.

Yes — every integration is a git repository, with history, branches, comparison and merging in the interface. A repository can be mirrored to your own GitLab or GitHub, so the source code is always in your hands as well.

Yes. It includes an SFTP server for partners where a folder can be watched so an arriving file starts an integration, S3-compatible storage for data, and scheduled runs.

An overview shows integration status, errors and traffic volumes, and logs stream in real time with filters. You can assemble your own views from widgets, and from any chart you can drill down into the log lines the number came from.

An alert rule watches the logs over a chosen window, and it can also fire because an integration has gone quiet — the alert for something that stopped, not just for something that broke. Alerts are delivered by webhook to Teams, Slack or an on-call system, and an alert can open an incident with an owner, a state and a timeline.

Yes. The execution history keeps the original message for a chosen retention period, and it can be resubmitted as a new run. A resubmit does not alter the original execution, so the history stays readable.

The run is painted onto the flowchart: which steps ran, how long each took and where it stopped. Around a log line you can open the lines before and after it, and a single event can be explained by the AI right in the view.

An integration is built into a versioned container that is deployed to a chosen environment. Rolling back to an earlier version is one action, and the view always shows which version runs in which environment.

Yes. An integration can pause to wait for an approval, a choice or a missing detail, and the question appears in a named person's work queue with a due time. The answer flows back into the waiting integration.

Secrets are held in a secrets store — FastHub's own or your Azure Key Vault — and delivered into the running integration as environment variables. Values are never shown back in the interface, every secret has version history, and secrets are per environment.

Yes. The same integration is deployed to different environments with their own settings and secrets, and environment-specific settings can be changed without a rebuild.

FastHub is built in Finland and hosted in the EU. Alternatively the whole platform runs in your own data centre or cloud environment, in which case the data never leaves it.

Yes to both. The platform installs into your own environment as a Kubernetes package just as readily as into the cloud, and AI models can run locally via Ollama. Then even the AI features need no connection to the outside world.

Users carry roles that decide both which views they see and whether they may view, operate or administer. You can define your own roles, and a role's actual access can be checked in the admin view before you rely on it.

Yes. Every mutating action records who did it, to what and when, and the log is searchable. Administrator terminal sessions are recorded for review afterwards.

Message content capture is a per-integration setting and off by default — the structure, timings and errors of a run are visible without it. When content is captured, you set a retention period and its size is capped.

The platform is GDPR compliant and built for EU market requirements, and ISO 27001 certification is in progress. We're happy to go through the current state in detail for your assessment.

Updates arrive as versioned packages and you can roll back to an earlier one. Platform databases are backed up on a schedule with a retention period, and backups can be encrypted so the decryption key never lives in the cluster.

Partner traffic lands on a separate edge service in its own cluster that authenticates every request before it goes any further. Keys are stored hashed, and per-partner quotas and IP allow lists apply.

Pricing is monthly and starts from €200 per month. The final price depends on the number and scope of your integrations — we'll send the full pricing model and calculator on request.

No. You can cancel at any time; we'd rather earn the next month with service than with a lock-in period.

You can use your own model credentials or the credits included with FastHub. Either way the usage is itemised, so the cost never comes as a surprise.

None that are mandatory. The platform is meant to be used by your own team and support is part of the agreement. If you'd rather we built the integrations for you, that is agreed separately — it is an option, not a precondition.

The integrations are standard technology and their source code is in your own version control — the repository can be mirrored to your GitLab or GitHub while you use the platform. What you take with you is working code, not an export format.

Yes. FastHub is backed by Devikone, which has delivered hundreds of integration projects. We can build the integrations for you, build them together with your team, or leave them entirely to you.