How to learn Airkit

As a software engineer, learning how to build in Airkit depended on how I framed the studio in my mind, and how conceptually everything in the studio fit together. I want to help speed that process along, and hopefully assist you, in conceptualizing the build process and developing applications as fast as possible, so I have laid out my thought process around Airkit below, and how I learned to build applications in the studio.

Resources to Help You Get Started 

Before covering the core concepts behind building in Airkit, we should point out the other avenues of learning available to you as a builder.

• Airkit Documentation
• Airkit Builder Community
• Airkit’s YouTube Channel

These all proved to be hugely helpful in my own learning, and hopefully they’ll be the same for you.

 A Viewpoint on What Building in Airkit Looks Like:

The framing I found most helpful to me when I started building in Airkit was thinking about the various builders in the studio as if they house the various parts of full stack application development. Some function as the front end, some as the back end, and some as the services and functions that tie everything together. There are a few concepts that match pretty well 1:1 with full stack development, so let’s cover those first.

A Look at the Front End

Several parts of Airkit match pretty perfectly with the concept of front end development, and that primarily lives in the Web Flows Builder. It provides various controls and elements you can drag and drop into a Web Page, and using these you can create user flows and customize the functionality of the front end of your individual Web Pages. This can be anything from text inputs to file upload controls (there are even templates available for more complex controls like Customer Satisfaction surveys and payment collections).

In Airkit, you also have access to variables at various scopes to use throughout the application. You can access and assign values throughout the studio itself, including in requests or functions that you use to access internal backend systems or external systems like API calls. You also have access to Airscript, the super easy to learn programming language internal to Airkit building. Using Airscript feels a lot like writing functions in Excel or Google Sheets, and it allows you to easily transform and access data, and use it to fill in controls on your Web Pages. Thinking about the “front end” of the application as a combination of these tools helped me get started on that process more quickly in the studio.

A Look at the Back End

As for the “back end” of Airkit applications, the studio comes with an internal system of storage called AirData. This maps pretty one-to-one with a database system for a web application. It can store and display any kind of data used within your Airkit app, it can be queried within Airkit, and certain fields can even be encrypted. 

Additionally, the Connection builder houses all kinds of typical back end and server functionality. For example, you can create data flows that query the AirData objects mentioned above, or you can generate API calls and HTTP requests to query for and utilize external data and systems. You can even create API endpoints that trigger your application. 

Extra Features: Talk and Text

There are a few extra features that come with Airkit that would have taken me much longer to develop if I were building out applications traditionally, namely Voice and Chat bots. By connecting a Twilio number to my Airkit account (which was shockingly easy since the integration is one of Airkit’s out-of-the-box features), I could connect that number to either a chat or voice bot, and connect it to my application in a matter of minutes.

You can customize the specific responses of the bots, send out notifications or nudges, 

 and even build out decision trees based on what a user might say or send back to these bots, all through simple logic. This was a HUGE eye opener for me, seeing how such a complicated process had been simplified into such an easy task.

Putting All These Pieces Together

Finally, there are builders and components of Airkit that bring the application together with a professional finish. You can store brand assets and styling in the Theme builder so everything remains consistent stylistically, and in the Configuration builder, you can fine tune other aspects of the application, like authentication flows, integrations with external tools, and deployment preferences. Again, all of this complex functionality I was able to do with a few clicks and inputs, and they were ready for deployment.

One concept to keep in mind when building in Airkit, and the one I found most difficult when getting started, is that of Journeys. I like to think about Journeys almost as if they’re a typical UX flow of an entire web application, but with a lot more processing power.. The Journey represents the entire beginning, middle, and end of a user going through your application, and how a user interacts with each part of the flow you send them through. Journeys do, however, contain stateful information about the user moving through the application flow, and can provide incredibly useful insights while building.

Taking This Knowledge and Building in Airkit

So, now you have a frame of mind to take on while starting your Airkit learning journey, but what do you actually do next? What are the actions you need to take to just get started already?

Here is how I personally tackled the studio, my order of operations if you will, which might help you as well! Feel free to rearrange this with what you’re most comfortable with, these are just the steps I found helpful when working through an application as if I were building it out traditionally.

1. Build a simple form app! We have a video tutorial that walks you through exactly how to do just that. Just creating a super simple application from start to finish is a great tour of the studio and what it can do.
2. Starting poking around integrations. A great and simple one to start with is integrating with the Giphy API. We have documentation all about integrations that can walk you through the process step by step.
3. Practice the flow of data to web pages, like how you connect data flows to web flows specifically. We have a short video walkthrough here.
4. Start working more with variable scopes. Our documentation does a nice job of explaining the namespacing of each scope, so start playing around with an application and make one of your variables globally scoped, and see how you can adjust your application around that.
5. Get more familiar with Airscript. I didn’t touch too much on this until I was more familiar with the studio, but it’s extremely powerful and can help you achieve functionality more typical in traditional development environments.
6. Add a chat bot to an app you’ve built! There are great documentation articles on exactly how to do this, but I found just adding one to an application I already built to be helpful when learning how they worked.
7. Access an application through calling it as an API endpoint! The way I did this was setting up the endpoint in the app I had just added a chat bot to, and then triggering a text to my phone through Postman.

That should put you well on your way to building in Airkit! Remember to keep experimenting, and don’t hesitate to reach out for help from other builders on our community page!