Low-Code Development: A Comprehensive Guide for Tech Enthusiasts and Beginners
What is “low code” and why do developers cringe at the mention of it?
TL;DR
- Traditional software uses skilled & costly engineers, who build from the ground-up using coding languages like JavaScript or Python.
- Low-code is a visual development approach with less code, using drag-and-drop interfaces and templates.
- Low-code spectrum includes ‘no-code’ platforms with no coding, progressing to ‘developer tools’ with more code for enhanced functionality.
Here are some examples of low-code tools you might have seen before:
To help you understand better, let’s explore what the usual process looks like when building an app with traditional code.
What’s it like to build an app from scratch with code?
When creating software, there’s a lot to think about in the development process, known as the development lifecycle. If you’re building from scratch or using a low-code platform, the details of this lifecycle can vary.
📌 Note: Since I’m more of an web app girlie, I’m going to focus on that specific development process. But the concepts are reasonably universal for mobile apps, native apps, etc.
Setting up your backend
Software typically consists of a backend and frontend.
- The frontend interacts with the user and calls the backend for data.
- The backend manages data and logistics behind the scenes.
- Setting up the backend involves choosing a database type (SQL or NoSQL) and platform (MySQL, PostgreSQL, MongoDB).
- Decisions depend on various factors, beyond the scope of this post.
Once you’ve got everything set up, the next step is designing your database. This means creating rules for how data is stored and organized, including:
- What type of data it is (text, number, yes/no, etc.)
- How it’s organized (different tables and their relationships)
- Names for everything (columns)
After choosing your database type, you set it up on a server or cloud instance like AWS or GCP, often with staging and production versions for safe testing.
Once this is done, your backend is ready to store and manage data. For example, when someone signs up for your app, their data can be stored and easily retrieved when needed.
Now, let’s set up your frontend.
This is where you create the graphical user interface (GUI) and link it to your data. You’ll be coding components, actions, and more. Hosting is required, and sometimes it’s on the same server as your backend.
Frontends and backends can be built using various programming languages. Traditionally, HTML, CSS, and JavaScript were for the frontend, while the backend used languages like Java or C++. However, JavaScript has gained popularity for the backend in recent years. It’s important to note that developers often use prebuilt components and capabilities from software libraries, saving time and effort.
During the frontend step, you’ll go back and forth between developing frontend and backend elements. This involves making and debugging connections, adjusting your data schema as needed, and integrating new resources. Software engineering is an iterative process, and your frontend and backend work closely together.
App Management
Once your main product is good to go, most apps need additional features to manage how they’re used and improved. This includes:
Permissions:
— Decide who can do what in the app, like reading or editing data.
CI (Continuous Integration):
— Test the app regularly to catch and fix issues early on.
CD (Continuous Deployment):
— Quickly release new versions of the app to users.
Observability:
— Keep an eye on the app’s speed and reliability.
Documentation:
— Provide clear instructions on how to use the software.
While there’s complexity involved, the specific requirements can vary based on the organization. These are some fundamental aspects to consider.
Maintainence and Iterations
After finishing the initial work, you transition from building to maintaining your product. Products usually get better over time with new features, bug fixes, and enhancements for users.
It’s important to mention that these steps don’t cover the internal team discussions during planning, scoping the application, refining, and iterating on versions. In my experience, it often feels like the classic challenge of having too many people involved, all contributing ideas — imagine a lot of cooks in the kitchen, but with a very patient engineer at the center.
In short, creating apps from scratch with code is often a challenging task. The time it takes can vary widely — simpler apps might be ready in a day, while more complex ones can take months or even years to develop.
What’s It Like Building a “Low-Code” App?
Building an app with low-code tools can be similar or different from the traditional method we talked about earlier. The main point is this: using low-code makes app building faster and more accessible for people who aren’t super technical. However, there are some tradeoffs.
Firstly, low code allows more people to get into software development without years of computer science study. For example, if your marketing team needs a BI tool and you already have a database, they might use a low-code tool to build it themselves. If you’re a self-employed dog walker and need a website, you can probably create one quickly using a low-code platform like Squarespace or Wix.
The process of building an app with low code is usually simpler.
Setting up your backend:
- If you don’t have a backend, you can create one using low-code tools like Airtable or Google Sheets. These tools have user-friendly interfaces to interact with your data without needing a backend engineer.
- If you already have a database, you can connect it to your low-code frontend builder using a REST API or integration.
- In some cases, like most website builders, the database is integrated seamlessly, and you might not even notice it’s there.
Of course creating columns and adding data in Airtable is much easier than doing it with SQL in PostgreSQL. Whether Airtable qualifies as a “database” is a complex discussion, but for basic apps, it’s a great low-code choice.
Most platforms will automatically host your app or automation in the cloud, eliminating the need for the ‘finding a server’ step.
Setting up your frontend:
Components in apps are typically pre-built and drag-and-drop. This saves a lot of time and effort, sparing you from writing hundreds of lines of code to create basic elements like tables, buttons, and forms. These elements are standard in almost every app and can be a hassle to recreate each time.
The App Management Nitty-Gritty
Maintainence & Iterations
Because each element is easier to build with low code, making changes and fixes is quicker. Maintenance is simpler too, as the platform itself keeps many core computing elements up to date, and it takes care of things like API connections and servers. The platform usually notifies you if something isn’t working correctly.
These simplifications free up builders from repetitive or lengthy coding tasks. Instead, they can focus on core products or critical tools, creating unique functionality in their apps without worrying too much about building the basic components.
While some people in the software industry, especially marketers of low-code tools, see low code as a game-changer, many developers may have a different perspective. But why?
What’s the downside?
Does it seem too good to be true? Well, to a certain extent, it is. While low-code can simplify development, it comes with limitations, and the level of customization isn’t as flexible as traditional coding.
Here’s the catch:
1. Hitting the wall: Developers often resist low-code tools because they can hit a roadblock in terms of customization. With traditional code, you have more control, but with low-code, your app is limited to what the tool allows.
2. Learning curve: Users and developers using a low-code tool need to learn its unique features, which can be time-consuming. This is true for traditional code as well, but if you’re a developer, you’ve likely already started that journey.
3. Cost considerations: Using these builders extensively can become expensive, especially if they don’t cover all your needs.
4. Proprietary nature: Low-code tools often use their own language and building methods, making it challenging to transfer to other platforms, creating vendor lock-in.
Despite these limitations, low-code platforms aren’t useless. Depending on the app you’re building, you can get cool products quickly. However, it requires research to find the right tool for the job. Just like anything else, picking the right tool is crucial.
Considering the downsides, what are low-code tools good for?
1. Creating MVPs and Prototypes:
— Many companies use low-code platforms to build a minimum viable product (MVP) or a prototype. This serves as a temporary solution until they’re ready to build a fully customized product from scratch.
2. Fast Growth in Startups:
— Startups in rapid growth phases find low code useful. It allows for quick experimentation and building without heavy investment in a custom solution, which may change as the startup evolves.
3. Pitching Ideas and Budget Planning:
— Having an MVP is excellent for pitching product ideas to budget holders and funders. It provides a tangible demonstration of the concept.
4. Quick Solutions for Non-Technical Teams:
— Low code is beneficial for teams without engineering resources. It empowers semi-technical users to quickly solve certain tasks without extensive coding knowledge.
5. Developer-Focused Tools:
— Some low-code tools like Retool, Appsmith, and OutSystems target developers to speed up engineering time on internal tools. These tools are gaining popularity as their limitations decrease, allowing developers to build faster.
6. Streamlining Development Efforts:
— Incorporating low-code engineering tools into your development stack is a way to streamline efforts and save engineers time. While critical tools might not be suitable for proprietary low-code platforms, many mid-level apps could benefit from this approach, reducing the workload on engineers by around 70–80%.
Conclusion
Ultimately, low-code development is a valuable addition to the software development landscape. The key is understanding project needs and choosing the right tool — whether traditional coding for customization or low-code for rapid development. As technology evolves, striking the right balance between control and speed will be crucial for successful integration into the broader software development ecosystem.
