We are about halfway there now, with the following completed:
Templates for different page layouts
Resource development page
Drag ‘n’ Drop interface
Lists of processors (nodes) in the system
Ability to switch between the views with data loss
Import/Export resources locally
Processor info slideout drawer
Ability to enter input constants
Centre and zoom the view on the existing design
Re-order the nodes in the GUI
Unit testing (Vite)
E2E and Component testing (Cypress)
Styleguide (yarn styleguide)
Jdoc (yarn jdoc)
The develop branch on ApiOpenStudio core has been updated to include a refresh token. This extends the JWT functionality, so that when the existing login token expires, the user does not need to log in again (unless they have been away for over 1 week).
The next phases includes:
Adding unit tests for the conversion between Drag ‘n’ Drop data to JSON/YAML
Login & token refresh functionality
Replacing stub data with real API calls from an ApiOpenStudio core instance
This article explores the intersection of agile development practices and Integration Platform-as-a-Service (iPaaS) facilitated through low-code platforms. By analysing how the agile methodology synergises with the capabilities of low-code iPaaS solutions, this article aims to offer guidance on how organisations can navigate the evolving landscape of data integration.
The digital transformation journey of many organisations includes a dual focus on agility and data integration. Agile development practices have revolutionised the software development lifecycle by encouraging flexibility and collaboration. Meanwhile, Integration Platform-as-a-Service (iPaaS) solutions have emerged as powerful tools for integrating disparate data sources and applications into cohesive systems. The advent of low-code platforms is adding another layer of simplicity and speed to this ecosystem. This paper explores how agile development methodologies can be adapted to manage iPaaS solutions effectively, particularly when implemented through low-code platforms.
The Promise of Low-Code iPaaS
Low-code platforms promise rapid development cycles and democratise the integration process by enabling non-developers to engage in building and managing integrations. This aligns with the agile ethos of collaborative problem-solving and cross-functional teamwork.
Agility in data integration comes with its own set of challenges, such as security concerns, data governance, and the potential for “spaghetti” integrations. Adopting agile practices like iterative development, sprint planning, and regular retrospectives can aid in navigating these hurdles.
Agile Principles in iPaaS Implementation
Rather than attempting to integrate all systems simultaneously, agile principles would advocate for incremental, iterative integration. This approach allows organisations to learn from each integration cycle, making adjustments before the next sprint.
Collaboration Over Silos
Agile development calls for intense collaboration between cross-functional teams. When applied to iPaaS, this principle means involving stakeholders from business, IT, and data governance right from the initial stages.
Responsiveness to Change
One of the core tenets of agile development is responsiveness to change, which can be beneficial when managing integrations in a low-code environment. As these platforms enable quick changes, an agile approach ensures that the system can adapt to new requirements efficiently.
The natural synergy between agile development practices and the capabilities of low-code iPaaS platforms offers a promising avenue for organisations seeking efficient, collaborative, and adaptable data integration solutions. By leveraging agile principles, organisations can navigate the complexities and challenges that come with modern data integration tasks.
Hyrynsalmi, S.M. (2022). The State-of-the-Art of the Integration Platforms as a Service research. [online] IEEE Xplore. doi:https://doi.org/10.1145/3524614.3528634.
AltexSoft. (2021). System Integration: Types, Approaches, and Implementation Steps. [online] Available at: https://www.altexsoft.com/blog/system-integration/.
This document solidifies and defines the multiple definitions and sub-genres within the Low-Code and No-Code world.
No-Code – A visual software development environment where the user works only within a GUI. There is no programming or CLI involved. The system potentially allows plugins for added functionality.
Low-Code – A visual software development environment using a GUI and/or SDK. In addition to No-Code functionality, the user has the capability to also add programmatic code directly in the environment. The system potentially allows CLI and plugins for added functionality.
Low Code No Code (LCNC) – Low-Code and No-Code as a technology, referring to all or parts of a system.
Pro-Code – Single or multiple systems that are written in pure code, by a programmer in whatever language suits the task best.
Low-Code and No-Code have been around for several years, and the genre was first proposed in the 1982, when James Martin argued in his “Applications Development Without Programmers” book that 4GL technologies (such as RAMIS and FOCUS) “opened up the development environment to a wider population and enable non-programmers to create applications themselves” (Sassi, R.B. (2021). A Brief History Of Low-Code Development. [online] Medium. Available at: https://betterprogramming.pub/low-code-history-b756c095494f). As a response to the Waterfall Model, RAD gained momentum in the 1990s when the concept of visual desktop tools like Visual Basic, Delphi, and Oracle Forms became popular. Low-Code and No-Code gained wider traction in 2016, after a publication by the Forrester Group that made the term Low-Code public.
Since then, Low-Code and No-Code applications have enabled skilled developers to work faster and citizen developers to work on tasks that do not require as much technical knowledge but were previously purely within the remit of developers.
However, the fluidity and misuse of terms and labels describing this technology has caused a lot of confusion. In specific:
Formal definitions of the differences between Low-Code and No-Code are sparse and no two people describe them in the same way.
Two other terms have appeared recently: LCNC and “Low Code No Code”, both of which appear to define different things.
LCNC has often been used by the Low-Code community to describe how all the platforms have evolved by adding UI for repetitive tasks, i.e. small areas of No-Code to their platforms. Many Low-Code platforms offer No-Code functionality as well, such as Appian, Mendix, Microsoft PowerApps, OutSystems and Salesforce Lightning.
“Low Code No Code” has been used in the media to refer to all Low-Code and No-Code coding types as a whole (i.e. not Pro-Code). This phrase is mentioned as much, if not more than LCNC.
Solidifying the terms
In theory, the differences between LCNC and “Low Code No Code” are redundant and using an acronym of one term to mean something different to the expanded term leads to a lot of confusion. Therefore, we should have a single definition for LCNC and “Low Code No Code”, and only utilise LCNC as an abbreviation of “Low Code No Code”. Therefore “Low Code No Code” and LCNC should hereon refer to all Low-Code and No-Code coding types. This can apply to the entire application or part of it.
Despite the limited definition in the public domain for No-Code and Low-Code, we can lean on the two words “Low” and “No” to express pure UI drag ‘n’ drop interfaces vs GUI that also allow code (i.e. nearly No-Code).
So No-Code refers to applications that exist 100% in the GUI (drag ‘n’ drop and configuration).
Low-Code also exists in the GUI, but it also allows the user to define code, either in the GUI, SDK or CLI. Low-Code is different from No-Code in that it is much more flexible, however you need developer skills to use it (though less than traditional Pro-Code, which is the ultimate for flexibility). Low-Code has an advantage over No-Code, in that it is much more flexible than No-Code and can be used by a Junior Developer to move much faster than a Pro-Code approach.
A visual software development environment where the user works only within a GUI. There is no programming or CLI involved. The system potentially allows plugins for added functionality.
A visual software development environment using a GUI and/or SDK. In addition to No-Code functionality, the user has the capability to also add programmatic code directly in the environment. The system potentially allows CLI and plugins for added functionality.
Low Code No Code (LCNC)
Low-Code and No-Code as a technology, referring to all or parts of a system.
A system that is written in pure code, by a programmer in whatever language suits the task best.
The good old fashioned “it works on my machine” came back to bite us, but the code has been updated and it is now loomed correctly into the GitLab pipelines. Many thanks to laughing_man77 for jumping on this so quickly!
We’re pleased to announce that the issue has been resolved, and all tags have been re-uploaded to docker hub. So that was a really quick turn-around of 1 day (and we even had a chance to sleep on it before pushing it live).
Apart from the good news that full production images for ApiOpenStudio core and admin are fully working and tested, I also tested the released image on an existing server – and proved that the install time of admin is under 5 minutes!
What do we call the users of Low-Code or No-Code platforms that work for the IT dept?
Across the board, business and IT is seeing a transformation that is being driven by Low-Code and No-Code technologies. There is clear change in the job titles around development although the new terms have not yet stabilised.
Historically problems like this, are the indicator of genuine profound change!
Low-Code and No-Code is definitely not a replacement for developers or an IT department, and we will never be out of jobs (who will develop the Low-Code tools, who will design and build the surrounding complex architecture?). However, there are some great side-effects:
Business employees are learning the basics of
Development processes – the how-to and why they are beneficial, as Low/No-Code processes need to be constrained to stop ballooning and undocumented code.
Code and processes are more easily aligning with business processes.
This is an exciting time, not only because we are seeing those at the forefront of the new technology explosion see their ideas come to fruition, but also because IT departments will see more understanding from business (as they learn more about IT as they onboard with theLCNC applications and processes), and this is driven by business and economics.
The language problem
Across many eras in IT there seems to be one thing that stands out about true – long lasting and permanent changes to the IT landscape break the language used in the current IT ecosystem. So any “language break-down” emerging is evidence of a strong of a probable trend being confirmed as profound change!
Some changes are fast and have “epoch moments”. Some are slow and creep up on us, leading us to say “this has always been known, but we never said it before in that way”.
Economists note that the one thing that stands out about genuine largescale change, is that the new activity will change what people do, how they are specialised and the job titles that describe it.
A good example of this is web-design. Initially we just had “web-designer”, before shattering that role into multiple disciplines, as we came to understand that improving the interfaces on a website was inherently complex, and architecture was only half the problem. We now have roles like (SvenJenzer, 2023, Typical UX disciplines, [ONLINE] Available at: https://en.wikipedia.org/wiki/Parenthetical_referencing, Accessed 27 January 2023):
We need new job titles in development, so that Low-Code enabled developers can be classified in a way that reflects any extra value that they bring. While distinguishing them from citizen developers who, whilst they are not IT people, are doing ad hoc IT tasks to improve their role and also need a way of classifying their extra skills.
What is the solution?
Let’s look at the typical range of developer roles that we currently have:
We currently have no way of expressing the extra values that trained Low-Code developers and No-Code citizen developers bring. So, let’s break this down, essentially we are trying to express:
Value to the business
Potential leadership role
Area of expertise
Using these taxonomies, we could potentially create new titles to express these, such as ApiOpenStudio Developer, Senior RapidAPI Developer, Junior Zapier Architect. However, this does beg the question, are users of Zapier or RapidAPI developers or architects? To be honest, not really, and they are definitely not architects. So this will not suffice.
I’m not posing a solution to this yet, and just want to open the floor to a problem that is likely to surface very soon, when those that have spent the time learning these skills want to express their new-found knowledge recognised by the business, or businesses want to find workers with the assets and skills that they want.
APIs are displaying continued astronomical growth (see https://www.postman.com/state-of-api/api-global-growth/#api-global-growth) and are now a critical part of nearly all modern architecture. However, we have seen a lot of coverage recently of the different terms encompassed by the API First methodology, especially as people try to use these buzz-words to generate excitement over their products without fully understanding what they mean.
In IT, terms tend to evolve, due to the pace of change. But this is not the ideal way to create terms as it can lead to similar terms, causing sub-optimal communication, even mistakes. But unlike industries like aviation and maritime, which are the gold standard for communication, w do not set a standard and declaration for what precise terms to use and when, to prevent confusion, misunderstanding and planes and boats crashing into each other.
For instance, we now have the following:
(Yes, I know that some of these are unrelated to APIs, however there is a real problem with language here – everything sounds the same and confuses people)
“API First Design”
“Business First API Design”
“Api First Culture”
“Api First Company”
“API as a Product”
… and the list goes on…
I don’t know about you, but my head is rattling from all of these variants. This is getting ridiculous and incredibly confusing for everyone, requiring a lot of reading of articles to understand the nuances of the new terms that are being introducing and how these may subtly differ from the others.
As technologists, we need the business community to fully grasp the ideas and benefits behind the API first methodology so that we and they can make sound judgements on directions and strategies. This means that the ideas need to be immediately comprehensible and their ramifications obvious.
I am going to suggest that we throw out a lot of these phrases and keep things simple, but I won’t try to reinvent the wheel and create completely new phrases. For the rest of this article, I will only refer to 3 terms.
API First concepts
Each term has an impact on the technical and business strategies/successes in different measures. But each concept requires a full “buy-in” and understanding from the business.
Design the and build the API first!
The product is built around the API.
This is reflected in the business strategies and revenue models (see API as a product and API design 1st).
API-first is obvious from the business point of view. The API is the primary income generator or essential to other income product/s. Without a revenue model, you do not have a business. Therefore if APIs are the main product or critical to a product that is being created/overhauled, then the API becomes a crucial first-class citizen, not just for the technical dept, but also from the business.
Information and data are key to the modern business, right? APIs are the backbone for nearly all data communication.
Building a new product (not just API) is an expensive task, both in time and money. By going through a full design phase for the API, the correct emphasis and attention is given to the API that it needs, a lot of thought will be put into:
What data is being shared across the API.
Why this data sharing is required or wanted.
Who/what will be consuming the data (internal and/or external).
This will reveal any potential flaws or opportunities in assumptions that the business has made.
Ensuring that all business processes are made more efficient by the new agile data flow that APIs will provide.
n return, API First will have a causal effect on the business by ensuring that due diligence and research is followed before embarking on a costly venture of system build. A lot of thought will be put into what the business needs and why. Future projections and plans become much clearer.
This does not mean that all other resources sit in idle-mode until the API is built, in fact it can happen simultaneously. Once you have the API model built in documentation like OpenAPI or Redoc (quite early in the process), you have a model that can be used by consumers before you start the full development. This saves time and money on fixing broken assumptions, missing or inadequate requirements.
API as a Product
The API may be the core product, but not necessarily.
API as a product has 2 definitions:
External-facing API that is monetised
Indirect monetisation by a product that requires an API to function or public exposure and usage through a free public API.
API as a product, is tightly coupled to the API design-first concept. In order to implement business strategies for revenue driving APIs, good design and documentation is a “must-have” to enable third parties to consume the APIs, providing an easy-to-use, comprehensive and unified experience.
If the API product is well designed and documented, this will increase the consumption and efficiency of the API (and therefore income). Postman alone has seen very significant increases in traffic and API usage, despite the global downturn and Covid:
Since the 2021 State of the API report was released, the Postman API Platform saw significant surges in use: * Users: 20 million * Collections created: 38 million * Requests created: 1.13 billion
In general, this is a development model for APIs that ensures the following criteria are met:
Reach agreement from all stakeholders.
Design the APIs models first on OpenAPI or similar product.
Build the API.
Separate products can be built at the same time as the API.
API design first may not be quite so obvious from the business POV, because at first view, it is just a development process. However, because it requires approval from all stakeholders, it is critical to have business “buy-in” to the process. This enables all of the business to see what/why the API is being built, and ensures that everyone is agreed on the most critical features they need.
In addition, this results in a rare instance of a complete understanding of what is being built and why, by the technical department. Instead of just being told to “build this” by the business without any consultation between them on what the rationale is, what is technically feasible, or if there is a better solution, the developers and department see the vision and are able to work towards that vision in a much more efficient manner and the end result will be a much better product.
This all ties in with discoveries and revelations being made about “Developer Experience”.
Up until recently, a lot of research and time has been invested un user experience (UX) and there is no denying the value that this can contribute to the business by increasing traffic and revenue. However a new key realisation is being made about developer experience (DevX). Who will be directly interacting with and consuming the APIs (and therefore making critical decisions that will impact their business about what APIs to consume and the frequency)? That right, developers!
They will correctly discard badly documented or difficult to use APIs in favour of better APIs. This means your product will be directly impacted by the DevX experience!
If you are supplying an external facing API for revenue (direct with monetisation or indirectly by offering APIs free with the associated traffic, publicity and exposure), then DevX is crucial to maximise income.
If you are supplying an internal facing API, then good DevX will have an impact on associated systems design, development and maintenance. Business processes that interact with the API will be either made more efficient by a well designed API or made cumbersome slow and inefficient by bad APIs.
We now are seeing an exciting, 27% month on month growth in our install base of the Alpha version (ok “exciting” that’s a marketing term. We don’t normally use them, as that’s not us, but humour me – I think that’s what we are supposed to say).
We are particularly happy about this as we took the decision to launch ApiOpenStudio in an advanced form of Alpha. So we could get early feedback and build the best open source product possible.
So to celebrate this, and the approaching Beta release, which we now estimate is now only 3 months away.
We are offering a free 30 min support package to anyone who has downloaded the product.
As this will support our early adopters, as well as give us the best possible feedback. The key to building the best product possible.
This will be with our founder John (wherever possible), as we really want to get the maximum from this customer interaction.
So if you would like to take this up, please reach out to Matthew Greally on LinkedIn or the Contact Us form.
Its findings are highly encouraging, and reading between the lines, are a fantastic indicator that the industry is on target for a continued adoption of mobile-first, API-first and micro-service architecture.
Our key take aways from this report:
The API ecosystem is global and growing
Postman reports continuing growth in API activity:
Users: 17 million
Collections created: 30 million (up 39%)
Requests created: 855 million (up 56%)
There are many more people, other than developers using APIs
Developers are spending more time with APIs
< 10 hours/week: 33%
10 – 20 hours/week: 39%
> 20 hours/week: 28%
This was a rather surprising set of stats, and probably due to the respondents coming from API driven developers.
API first methodology
Encouragingly, there is increased awareness of the API-first methodology, and more businesses are approaching their architecture in this way:
Sadly, there was an inconsistent or lack of understanding of what API-first actually meant:
APIs are treated as “first-class citizens.” That everything about a project revolves around the idea that the end product will be consumed by mobile devices, and that APIs will be consumed by client applications. An API-first approach involves developing APIs that are consistent and reusable, which can be accomplished by using an API description language to establish a contract for how the API is supposed to behave.
Private (only used by your team or your company): 58%
Partner (shared only with integration partners): 27%
Public (openly available on the web): 15%
Lack of time was the biggest obstacle to producing APIs
JSON Schema is by far the biggest specification tool for APIs
Now this one really surprised us (we had assumed it would be OpenAPI 3.0, but that was below Swagger 2.0. Considering that the API documentation standards have still not coalesced into an accepted standard, there should be no surprises in movements here, and it has to be said that JSON Schema is fantastic, especially for defining complex, nested object types.
Quality is the biggest priority for APIs, above security
This was also a surprise to us, although it transpires that a lot of APIs consume public APIs and therefore we assume that when quality is specified, they mean quality of data and resource specification. Therefore leading to a better resource offering and more consumers of it.
The recent flood of articles discussing the way that Low-Code is changing the landscape of development have 2 key elements:
Low-Code is now clearly emerging as one of those enormous waves in tech, that will change the way that things are done across business and IT development moving forward. For both tech companies and non-tech companies (because everybody is technology driven).
In the future, it is really how these tools are used in unison with the company’s “Pro-Code” developers. Which is the real business problem to be riffed on and solved!
What does the new development environment that includes “Citizen Developers” look like? How will they interact with IT Departments and the Pro-Code developers?
Will Low-code replace Pro-code?
Up front we’d like to point out the answer here is something we are sure of. This will in no way reduce the demand or work for Pro-Code developers.
There is compelling economic reasoning for this. As while it is true that all companies want to save costs, we are in an increasing world of digital transformation, where every business is in reality, a tech business.
So the one area where you cannot start with cost saving, is technology. Companies will always be in a technology race to the leading/bleeding edge with their competition. That edge will always require having the best Pro-Code people you can get, as they provide the competitive advantage.
Paradoxically this means if you have that, you also need the best Low-Code resources for two reasons:
Low-Code enhances the output of your Pro-Code work force, doing vital but repetitive, non-challenging tasks. Speed means less hours, more output, and we all get that.
These are considerable the other benefits, beyond cost savings. One of which is the morale& job satisfaction of the Dev team. Developers universally report that in their ideal work environments, they want to be working on important and challenging tasks. Where they have the best chance of learning things along the way.
So Low-Code can reduce the time they spend on these less interesting tasks. Because you can’t make the tasks go away. The answer is to use a tool that lets you get more done in less time.
More accuracy and happier teams
The hidden part of all this is the organisation’s abilities to utilise No-Code/Low-Code and adapt to it.
In terms of moral & satisfaction, there is clear evidence that the most onerous of tasks are the organisational ones. Like storing names & levels of permission on an API, in the case of ApiOpenStudio. These often have a high cognitive load because they require high concentration but they are in no way interesting. Low-Code solutions come with User Interfaces and Dashboards and these reduce cognitive load and risk in these tasks by making the tasks simpler and providing ways of validating your entries are correct and making the editing/deleting of changes easy. So there are huge benefits in day-to-day operations.
Learning a new technology and skill can also be fun. As we know, the primary driver for nearly all employees and their job satisfaction are:
Confidence in the leadership team.
Implementing Low-Code in a balanced way will demonstrate that the leadership have a forward-thinking mentality.
The employee is valued.
Providing training in the new technology and processes will show that the business wants to keep them and invest them.
Satisfaction with daily tasks.
The employee will feel more satisfaction through more responsibility and seeing their work being visibly used.
Learning and growth.
We all want to grow and extend out knowledge and usefulness, with the additional benefits of making us more desirable to employees.
With the decision to introduce Low-Code platforms, your first issue should be governance and compliance.
Your “Citizen Developers” and Project Managers should start to deepen their communication and feedback loops. Most importantly, non-technical people have to really feel they can come to the experts with the most basic questions, even if it is just to check they are on track. This is all new to them and they are not professionals in this sphere.
Because deep, first-hand knowledge of requirements is another advantage that citizen developers brings to the table. It’s worth noting that their approach will usually be decided on the functionality that they want. The effects on governance or the rest of the architecture are normally the furthest from their minds.
So from a Project Management perspective, clear leadership is needed right at the start in setting out the processes needed on the project. So that features and functionality are plumbed in properly.
There needs to be clear communication between the citizen and Pro-Code developers (usually via the Project Manager), but this can also be direct. This will ensure that any requirements between the two teams are met and no-one is adding useless things to the system, or features that will slow down the system performance.
Once you have initiated a communications format between citizen developers and the development team, then testing and documentation can be mapped out.
A clearly written and easy to access set of documents will be required by both your citizen developers and all levels of the development team.
This will ensure that:
Onboarding is quick and easy for citizen developers and they can quickly find answers to any questions that they have, without feeling overloaded by technical answers.
Managers and project management have access to sources of truth that enable them to answer any questions.
The Pro-Code developers are aware of the Low-Code systems and how they interact with their work.
Leaders of the development team can easily find a broad overview of the different systems, the interaction between them and the processes that have been implemented to govern them.
Depending on the complexity of the No-Code solutions and their impact on the rest of the technology, it is very likely that extra guard-rails will have to be introduced. This will probably involve QA (quality assurance), the ability to import and export configuration, and the release cycles.
Even if the output of the citizen developers is content (for example: pages in a blog or CMS), there should be systems in place to accomodate proof reading and validating the look and feel on different devices. There are additional complexities here, if the content that the citizen developers create is all in a database and cannot be imported/exported – where will this be tested, how will it be released? Although this issue is usually solved by that specific technology’s community, time should be spent looking at the different solutions proposed to find the best solution for your organisation.
In the case of complex No-Code solutions that interact with the output from the development team, then these need to go through the full QA feedback loop. QA can then validate that the existing functionality is not broken and that the new functionality works as expected and different systems interact as expected.
What is important, is that that the development team should reach out to the management of the Citizen Developers, so that they can have the discussion with them about compliance and governance & how they must comply with the IT departments direction (and vice versa). This is often an issue in companies, where people directly report in their department, and are in effect silo’d from the other departments.
Moving into the era of Low-Code/No-Code enhanced Companies.
The organisations that are going to maximise the benefits of this new wave, should already be initiating broad company-wide conversations. These will range deeply across all levels of the organisation. From the way that Pro-Coder work days and productivity will be enhanced to evaluating the advantages and disadvantages of implementing Low-Code solutions for specific tasks.
This will even permeate as far as hiring & the HR Dept. As you look to harvest the advantages of onboarding people in traditional roles that have these additional skills, or incentives for current employees who wish to acquire No-Code or even Low-Code capability.
This is the conversation of the future for all companies that will succeed in this new era!