Why Development Agencies Need To Take A Serious Look At Form.io

Remember the first time you drove by yourself after you got your driver’s license? You look over at the seat next to you and pause for a few seconds. For the first time it’s empty. A big smile stretches across your face as you place one hand on the steering wheel and start the car with the other. Freedom.

No more waiting to be picked up. No more having to get rides from someone else. You can go wherever you want. A whole new life has opened up now that you have your driver’s license.

Maybe this wasn’t your exact experience when you first obtained this kind of freedom, but you get the idea: life was forever different after that moment.

Discovering Form.io is like this for development agencies who build business applications because it solves the exact problems their development teams deal with, who aren’t just building something once, but always have multiple projects on the horizon, each with their own requirements.

Form.io is freedom because it makes that much of a difference. It’s about having total confidence in your team’s ability to deliver because you’ve hired the best and given them the best tools.

So if you’re a development agency, let me show you:

Why you should take a serious look at Form.io for application development
How you can tell if Form.io is right for you
And if it is, how we can work together to help each other win

One more thing before I proceed.

As soon as I start explaining something you’re probably going to be thinking “What about X, Y, and Z?” I have some ideas as to what X, Y, and Z might be, so keep reading.

You Don’t Have to Reinvent the Wheel

When building custom business applications, you’re dealing with forms and potentially all kinds of different fields (components). Right off the bat, Form.io gives you the ability to build forms and nearly any kind of component you can think of with drag and drop and then embed them in the application you’re building with one line of code.

However, I’ve said this before: A. Form. Is. Never. Just. A. Form. If we’re dealing with forms, we’re dealing with data. So when you build a form, multiple API endpoints are generated automatically so you can connect to that form, individual field, or individual submission, and do something with the data.

Now, if you did all this from scratch, then you’d first have to define the view of the form in your application code, like this:

<field …>
<field …>
<field …>
<button …>

And then you’d need to validate the data and tell the form where to send the data with a controller, which is also in the code, like this:

onSubmit(values) { 
axios.post(‘/form-a’...);
}

For each and every form.

Which means if you need to make changes, you have to update your application code, which triggers a CI/CD cycle and all the heavy lift involved with that.

With Form.io, you define a form’s view in your application code by pointing to its source, which never changes (unless you rename it), like this:

<formio src=”...”>

The form is then rendered with the platform’s rendering engine and no controller is necessary since the Form’s JSON indicates how to handle the data.

Which means when you need to make changes to a form, you aren’t updating application code, and you aren’t triggering a CI/CD cycle. Instead, the changes are made in the drag and drop builder of the Form.io platform. And once the changes are saved, the newly updated forms are already in your live application.

There are staging and development environments within our platform as well so you don’t have to make the changes in the live environment if you don’t want to, in case you were wondering.

And real quick, every form, every field, every submission, every API, basically everything is stored as a JSON object, which has essentially become the universal data structure across technologies. And this means the data you collect and route is compatible with most everything else.

So at a fundamental level, we don’t believe development agencies need to be spending time and resources building and managing forms or their APIs, especially directly in their application code.

The ability to drag and drop forms and APIs AND their decoupled nature being separated from application development, together, saves hours upon hours of development time.

Not a Service

I don’t want you to think of Form.io as a service you connect to in order to get these benefits. What do I mean?

Consider the application you’re building: you need to authenticate your users. Are you going to build your authentication from scratch? Probably not.

Likewise, think about the database you’re using. Did you build that from scratch? Probably not.

I’ve also talked about this before, but I want you to start thinking about forms and their APIs like these elements of application development that you don’t build yourself from the ground up:

You’re not going to build your own database, you’re going to leverage an existing database technology
You’re not going to build your own authentication schema, you’re going to leverage an existing one
You’re not going to build your own email provider, you’re already using an existing one

Even though you’re not building these things from scratch, are they any less a part of your application? No. They’re still very much part of your application because they’re fully deployed in the application.

You don’t have to build your own forms and APIs from scratch, you can leverage the Form.io platform with its drag and drop builder to quickly build forms and APIs, which are fully deployed.

Everything is in your own environment, even the platform’s tools that aren’t part of your application.

So you’re not calling out to Form.io as a third-party service.

No. Instead, you are deploying the Form.io platform in your own environment and accessing it directly.

This means you can use the tech stack you’re already using.
This means the whole platform is within your security umbrella.
This means you can allocate resources to core application development.
This means you can store the data wherever you want.
This means you have a repeatable system, a strategy for building forms and APIs for many applications.

FWIW, we do have a SaaS offering, but 90% of our customers self-host.

What I’m getting at here is that there are a number of common things in business applications that most everyone needs, but are too often being built from scratch over and over again.

Or you’re buying third-party software or using a SaaS that’s highly opinionated, forcing you into an ecosystem that requires things be done a certain way which you may not prefer, and is hard to get out of. It’s the classic make vs. buy dilemma.

What if you could buy something that handles all this common stuff for you, and is maintained for you, but still lets you build your app the way you want, because it’s THIN, it’s flexible, and deploys in your environment?

Too often we think buying or sourcing a solution from an external provider means obtaining an external solution. But with Form.io, you’re buying from an external provider for an internal solution.

And when we do think of buying or sourcing an internal solution (like a database or email provider), we don’t naturally consider forms, APIs, Action Workflows (more on this below), etc. as being part of that category.

But those that do consider it, which you probably are because you’re reading this, will eventually ask themselves “Does something like this exist and if so, how does that play out?” Good question.

It’s gotta be something that has the flexibility to let developers interact with it from their code and not get in their way, while at the same time providing the tools they need to handle all the common things on repeat without involving their code. It’s a delicate balance.

Skinny in the Middle

Form.io doesn’t swoop in, take over everything, and lock you in. Instead it’s a thin middleware that gets along with whatever you already have. What do I mean by this?

Basically everything is an API, which are bridges to other data sources with their own rules of engagement represented by a URL (you probably already knew that). Let’s say you or one of your customers has a user database with its own authentication. You’re not going to duplicate that database into Form.io. You’re just going to bridge to it with the Team API and call that database when needed.

Want to prepopulate fields with data from some other data source? API.
Want to store file uploads in your existing AWS/GCD/Azure store? API.
Want to send submission data to your existing database? API.

So it’s not a monolithic ecosystem of hard to swallow pills. It’s nice and thin and slides right into your tech stack and gets to work.

Many of our customers don’t even store data in Form.io. Instead, they use it as an inventory of forms and APIs and the primary hub for routing data to various places.

Decoupled Workflows

When a user interacts with a form submission, stuff needs to happen. For example:

Save info in your database
Send data to a third party system or service via webhooks
Send an email notification or 2FA
Update a Google Sheet

And often each of these should only trigger based on specific conditions.

Traditionally, all this is done in your application code, but It doesn’t have to be this way, at least not for the most common stuff.

With Form.io, you can configure multiple actions to fire on a form based on CRUDI activity (Create, Read, Update, Delete, Index (Search)), each with their own conditional logic.

All of this can be configured in the Form.io interface without having to modify your application code, again, without having to trigger CI/CD activity: decoupled. And when the case matters, each action will fire in the order you specify.

I Am Only Scratching the Surface

I haven’t even discussed the robust, feature-rich nature of the forms and toolset, including things like:

Conditional logic
Client and server side validation
PDF intake and output
Audit trails and logging
Multi-tenancy
Integrations
File Uploads
Multi-pag wizards
Reporting
Group access, roles, and permissions
Accessibility
Mobile responsive
Customizable with CSS

There’s more, but the point is, all things considered, you’re looking at prototyping in days, achieving an MVP in weeks, and shipping in at least half the time it would have taken you otherwise. These guys built a CRM in 2 months instead of what they estimated would take 2 years.

Configurable, Customizable, Reasonable, And Responsive

The Form.io platform is built with an open source core. Much of the platform can be customized and configured to do what you want. Want to build your own custom component? Go for it. Want to do something unique with how forms are rendered? Do that too.

If you want to know exactly what is open source, check this out.

When I say reasonable, what I mean is reasonable pricing. We DON’T price:

Per form
Per submission
Per end user of forms
Per form builder
Per developer
Per API call
Or any other usage-based metrics

We DO Price:

Per project (collection of related forms)
Per API/PDF environment (independent, scalable, and load-balanced servers for your SDLC)
Optional enterprise feature addons

In other words, we price based on the configuration you need. This means you’ll never get blown out of the water with a crazy high bill because of scaled pricing. Whether there are 1,000 API calls or 1M API calls in a month, the price stays the same because it’s based on the configuration, not the usage. For details and some examples of what a configuration looks like, check out our pricing page.

When I say responsive, what I’m talking about is our support. Email responses are always the same day or the next day from someone who is technical and knowledgeable. No delays. No run-arounds.

Plus, we maintain and update the platform at regular intervals. Not just bugs, but regular updates, improved compatibilities, and new features. See what NDIS had to say about our support.

So Is Form.io Right For Your Agency?

The easiest way to determine this is to have your development team try it out and see if they love it. There are two ways to do this:

Sign up for a Free 30-day Trial of our SaaS Platform. Even though this isn’t our deployed solution, it’s the exact same tool and experience you get if/when you do deploy Form.io. You can start building and embedding forms today.
Try a Free 30-day Self-Hosted Enterprise License OR a sandbox license (more on that below) that you can deploy in your own environment. Schedule a call with our team for an introduction to Form.io and tell us about what you’re building. We’ll help you choose a configuration that best fits your project.

Developers get JSON-driven forms with instant APIs, role-based access, CI/CD-friendly configs, and easy embedding. They’ll get accelerated SDLC with their applications. We hear this a lot from our customers.

Let’s Win Together

Join us as a partner and unlock new opportunities—for growth, innovation, and long-term success.

But not like other partnerships. We encourage/embrace non-invasive, marketing-focused partnerships.

You might be thinking, “what does that mean?” Good question.

It means no cost, no quotas. No heavy lift. Instead, think of co-marketing endeavors like webinars, case study spotlights, and/or field events.

What You Get:

We provide your team with:

A free sandbox/demo license of Form.io that you can stand up in your environment to demo to your customers
Solution briefs for how to deploy, configure, and use Form.io for various use-cases
Partner-level technical support
Our involvement with your customer presentations if desired
Get business referrals from us for aligned business opportunities
Potential partner-level discounts

You keep the customer relationship and delivery, we help you win and accelerate.

If a partnership with Form.io sounds like a great fit for your agency, we’d love to hear from you. Fill out our brief partner application, and let’s explore what we can build together.

Partner With Us