Categories
Blog

Speed, scale and savings: Three reasons ISVs must adopt low code in 2021

In 2020, Forrester had predicted that 50% of developers will use a low-code product. And then the pandemic happened. Instead of derailing the prediction — like the pandemic did for most trends of last year — it accelerated it. So much so that Forrester predicts that the “accelerated adoption of low-code platforms will change how teams organize.”

Today, low-code is no longer one of the many tools that help development, but a strategic initiative that fundamentally shapes the way software delivery will happen. Enterprises already understand this. For independent software vendors (ISVs) though, this can be a different ball game.

Why were ISVs resistant to low code

As a ‘software company’, most ISVs pride themselves on having excellent developers, building products that are robust, customizable, secure and scalable. For long, low-code development was seen as a means for citizen developers or business users to build prototypes, which then the ‘real developers’ built by hand. With reason.

Most low-code development platforms available today can not handle complex business logic or application requirements.

Until now.

What low code can do for ISVs in 2021

If there is one change that 2020 has brought to the world, it’s the widespread acceptance of remote work. For employees to work remotely, enterprise software needs to work remotely as well. This shift to the cloud, and perhaps a SaaS model, requires ISVs to rapidly modernize their software. Low-code can enable that.

#1 Fuel rapid application modernization

Low code can make software development faster by 10 times, as compared to traditional methods. Features like reusable elements, drag-and-drop and process modelling let individual developers or small teams release in days or weeks! Pair it with an agile-DevOps process, and it can modernize legacy applications to support enterprise needs of the future, without any disruption to current paying customers.

With low code:

  • Existing teams need no reskilling. Developers and even business teams can be onboarded quickly and can use the product effectively.
  • Existing processes are not disrupted. A low code platform like WaveMaker integrates with existing processes to enable modernization.

#2 Enable scale without compromise on customization

ISVs often maintain multiple implementations of their products for each customer. Even when on cloud, modernizing applications across these implementations — and their customizations — can be a complex endeavor.

Low-code platforms like WaveMaker leverage component-based models and micro-services with session-less architecture to build large, customizable applications at scale. With simple API integrations, ISVs can also ensure their applications work seamlessly with a wide range of other software that the client uses. 

With low code:

  • ISVs get complete ownership of code that the platform generates. Any edits / customizations needed can be handled effortlessly.
  • Development teams get to choose and maintain their coding infrastructure.
  • There is no runtime dependency.

#3 Save costs

The biggest advantage of low code development is that it doesn’t require ‘specialists’ for every function. A lean team of professionals can use low code to build or modernize an entire application. With powerful abstractions over technical programming, low code platforms can empower development teams, making it easier for non-specialists, junior programmers and even citizen developers to build software.

Low code reduces expenses both for the ISV and their end customers. It also frees ISVs from the expense of regular maintenance, while reducing development costs multi-fold.

With low code:

  • Dev teams can generate and maintain open standards based code, without needing specialists for each function.
  • The consistency of code generated ensures longer usability and easier maintainability.

WaveMaker for ISVs

Unlike most low code platforms, WaveMaker is built to handle extreme customization, enterprise-grade security and scale, all of which are essential for ISVs.

  • Open-standards based code uses popular frameworks like Angular, Spring, Hibernate, Cordova, etc. to help modernize apps without full scale development.
  • WaveMaker’s Java-based platform ensures rapid development, easy integration, responsive design and scalable architecture.
  • It combines micro-services with session-less architecture and auto-generated REST API to build customizable cloud-native apps.
  • It keeps data secure with RBAC and protection against Top 10 OWASP vulnerabilities.

If you’re an ISV looking to leverage enterprise-grade low code technology to modernize your application, get a demo or contact us here.

Categories
Blog

Seven assumptions to avoid when considering low code platforms

In the journey of digital transformation, the path to modernization could be a challenging one. When faced with technology modernization, dealing with legacy systems such as 5250-based, green screen applications, tightly coupled business logic, monolithic code base structures and limited knowledge of the application architecture, what choice do you have? You take a look at what’s trending in the market. You observe that there is an increase in the spending on low code technology (to the tune of $21.2 billion by 2022). Consequently, you decide to get on the bandwagon.

You choose a low code platform and begin the process of modernizing your applications. Fast forward a few months and you realize that the easy to use, drag-and-drop feature is great to build a prototype but the platform falls short in etching out the intricacies of a serious enterprise application. You also realize that when you want to scale up and build more applications and increase the number of users there is an additional cost. Added to that you have runtime dependency and added cost of deployment on infra of your choice. These among many other challenges edge you towards a reality check and it makes you wonder whether, in the urgency to modernize and be competitive, was the low code platform a right choice?

Every enterprise is keen to ride the low code wave, and in line with the modernization narrative, they should. The challenge arises when low code is adopted without learning about the ‘nuts and bolts’ of the platform and understanding how it fits their requirements. This is when a reality check occurs, when there is a glaring gap between expectations and reality. More often than not, the reality of technology modernization and digital transformation is different from what is expected. It’s a fact that while companies have reportedly spent $1.2 trillion on digital transformation in 2019, analysis indicates that just 1% of these efforts would actually achieve or exceed expectations.

Expectation Vs. Reality. Bridging the Gap When Adopting Low Code

Assume nothing. Know what to expect to mitigate reality checks 

Before adopting low code, it is important to take into account the expectations and requirements of different stakeholders. CIOs, CTOs, Application and IT Leaders expect that an investment in a low code platform must speed up time to market of application development and delivery, reduce operational costs, address the skills gap, bridge silos between users, developers and IT teams, ensure scalability, and promote growth. IT teams expect low code platforms to take the pressure off by enabling business-users build their own applications with minimal IT support, thereby giving them the bandwidth to innovate.  Developers are a league of their own, and assume that they “tell” the platform what the application should be. Professional development teams expect low code platforms to automate time-consuming and mundane tasks of code generation, so that they can focus on developing application features that will provide differentiation and improve user / customer experience.

Taking into consideration these different expectations, let’s take a look at some of the assumptions that create the gap between expectations and reality, and what can be done to reduce it.

Assumption 1: The platform is built for enterprise-grade application development

  • Expectation – You assume or expect that all low code platforms are designed for professional developers. That the low code platform has the technology stack and architecture to help development teams build complex, enterprise-grade applications.
  • Reality – Not all low code platforms support professional application development. Most platforms are designed for citizen developers or business users who typically build prototype or shadow IT apps using template-driven UI.
  • What could be done to reduce the gap – Take into consideration the technology stack offered and the platform architecture to understand if it can support serious, enterprise-grade application development.

Assumption 2: Low code will replace coding

  • Expectation – With the promise of a WYSIWYG development environment and visual drag-and-drop application development, you expect that by using a low code platform it will replace manual coding.
  • Reality – Complex, enterprise grade applications usually have intricate business logic. Building a rich application often requires developers to go native and there is a certain degree of manual coding needed to give attention to details of the application.
  • What could be done to reduce the gap – Low code application is not about replacing manual coding it is about optimizing the time of developers. When adopting a low code platform, you need to maintain a balance between low code and high code. In this way you can shorten the time frame of time-intensive tasks such as testing and allow developers to focus on other intricacies of application development.

Assumption 3: The platform generates quality code and testing is not required

  • Expectation – You assume that as the code is auto-generated and not manual there would be a lesser chance of errors. You may also expect that the low code platform generates quality code and has built in security and testing features therefore applications built would function successfully.
  • Reality – Some applications built using low code fail to perform, owing to several reasons, from coding or business logic errors, integration issues, to security threats.
  • What could be done to reduce the gap – While the promise of low code is to build applications that would be functional and secure, you need to have a testing strategy in place. You need to ensure the platform has features across the development lifecycle to test applications for functionality and security.  This would reduce the level of risk associated with implementation failures and security threats.

Assumption 4: The platform is scalable and supports increasing growth

  • Expectation – You assume that you can easily scale up to build unlimited number of apps and support an increasing number of users at no additional costs.
  • Reality – When the time comes to build more applications, increase the number of users, or move to another development environment, you realize many low code platforms have an additional cost involved and do not have the capabilities for scaling up.
  • What could be done to reduce the gap – It is important to assess if the platform provides dev-time and run-time scalability and consider if the licensing model of the low code platform fits your scalability needs. While there are platforms where you need to pay to increase the number of users or applications you can develop, there are pricing models where you can choose to pay per developer. Therefore, identify your scalability needs first to make sure the licensing model is suitable.

Assumption 5: You are not locked in to the platform and can customize applications after migration

  • Expectation – In a situation when you need to migrate to another platform, you assume that the low-code provider can provide the assurance you will be able to generate the code and recompile applications.
  • Reality – While your application may run, do you know if you can make changes to the code or are you locked in to the platform? Is the code readable to customize applications? In situations of migration, generated code is usually algorithmically accurate, although the code is not readable by humans, making it difficult for developers to make any meaningful code modifications required.
  • What could be done to reduce the gap – Given the significant impact of applications on operations, anyone using a low code platform must check and test the code generated. Make sure the code generated is syntax-agnostic and that the code is readable and customizable which are important factors in long-term maintenance of applications.

Assumption 6: There is no runtime dependency and you are free to deploy on infra of your choice without separate cost for deployment.

  • Expectation – You expect end-to-end freedom in using the platform, from application development to deployment. You assume there is no runtime dependence and that you can deploy applications on infrastructure of choice, from containers, virtual machines to on-premise infrastructure.
  • Reality – While application development is free, many low code platforms have a separate cost for deployment and use in-house runtime engines. The applications built on the platform are deployed on select clouds and in their environments, making it a challenge to gain ownership of code and rebuild applications.
  • What could be done to reduce the gap – To minimize operational cost, ensure the low code platform has an open-source runtime engine, one that gives access to the runtime libraries used and allows developers to customize applications without being locked-in to the platform.

Assumption 7: Underestimating the complexity of managing APIs during integration

  • Expectation – During the integration process, you expect the platform to provide developers with a visual approach to embed data elements directly into the application, connect to data sources, and even allow them to configure business logic and design data models inside the application.
  • Reality – This would probably work fine if your application is integrating with only a few other systems. The challenge arises, when you have to integrate more than a dozen systems and manage APIs.
  • What could be done to reduce the gap – When you have to integrate several systems, it is best not to underestimate the complexity in managing APIs. What you need to understand is the type of documentation that the low code provider offers and how it would enable managing APIs in the long run.

Modernization, as a part of digital transformation, is an intensive affair. Through 2021, Gartner  predicts that digital transformation projects, by large and traditional enterprises, will take twice as long and at double the cost than anticipated. On the other hand, smaller and agile enterprises will be more successful in implanting modernization and digital transformation initiatives. Regardless of this factual prediction, enterprises, large and small alike, can still gain leverage by adopting emerging technology solutions, such as low code. Solutions that constantly evolve, adapt to the challenges of technology modernization and make the journey of digital transformation smooth sailing and successful.

Categories
Insights

How low code can help enterprises “left-shift” application security

Modern enterprise application needs have become intricate. They demand application development and deployment to be cloud-native, agile, scalable, and secure. The app ecosystem has become intertwined, and enterprise applications have become complex beasts, built on monolithic systems. The transformation continues. Modern application development is becoming more agile and scalable and deployment of applications on the cloud is increasing. Application architecture is transforming from monolithic to microservice-oriented architecture. Developers and IT Ops are collaborating giving rise to the culture of DevOps. With the increasing pressure on high performance, DevOps teams are urged to use more sophisticated technology and techniques.

Besides achieving agility and scalability, DevOps teams are also entrusted with achieving application security goals. App Security has become a high priority goal and a shared responsibility. It’s reflected in Gartner’s “Magic Quadrant for Application Security Testing, 2020” report, there’s a 50% increase in the number of end-user and client conversations about AST (Application Security Testing) tools and DevSecOps in 2020.

To embed application security across the development cycle requires various levels of automation testing and setting up of configurations at different stages of the application development and deployment process. What development teams are doing is that they are using container technology and microservices to “pull security” early into the DevOps process. In addition to application security, another trend highlighted in Gartner’s report is the increasing attention (of 65%) on container security.

While many enterprises are already running cloud-native, microservices-based, containerized applications in production, there are several challenges; from technology immaturity, a steep learning curve, to the lack of operational expertise and know how. What’s taking precedence today in high-performance development teams is the “left shifting” of application security earlier in the stages of development.

“Shift Left” App Security – The Guiding Force Behind High Performance Development Teams

App Security has become a business imperative. In the Forrester’s Report on “The Top Security Technology Trends To Watch, 2020”, integration of application security tools with CI/CD pipeline is a major priority in 2020. Application security has become the primary focus of high-performance DevOps teams and by “left shifting” parameters, security is a shared responsibility and is being implemented by developers. Moreover, with the rise of DevSecOps the silos of application and infrastructure security are being bridged.

AppSec – The Primary Focus of DevOps in a Containerized Environment

DevOps teams not only have to mitigate operational issues related to performance, integrity, availability of containers in production environments, they also need to ensure security is embedded early in the DevOps process. With greater urgency to automate application security testing (AST) in the DevOps process, the attention of DevOps teams needs to be directed towards integration of the CI/CD toolchain with application security tools such as software composition analysis (SCA), static application security testing (SAST), and container security.

When embracing the DevOps culture and migrating applications to the cloud in a containerized environment, security must be embedded across the development lifecycle. To ensure compliance of performance and resiliency, the focus needs to shift to service-level and container-specific monitoring. DevOps teams need to monitor applications within containers and across containers at a service-level. “Pulling in” application security earlier into the development lifecycle would form the beginning of what is called DevSecOps.

DevSecOps – Breaking the Silo of Application and Infrastructure Security

The ‘mantra’ of DevSecOps is “shift left”, encouraging developers to move security from right end of the development and delivery process to the left end (beginning). True to its abbreviation, DevSecOps – development, security, and operations – ensures the integration of security is automated across the lifecycle, from application design, testing, deployment, and delivery.

With the essence of DevSecOps being “software, safer, sooner”, it enables seamless integration of application and infrastructure security with the DevOps process. By allowing developers to address application security issues earlier before the application goes into production, it makes security issues easier to fix without disrupting the development cycle. Breaking the security silo, DevSecOps makes security a shared responsibility of IT Ops, security, and development teams.

Integrating security and testing across the development lifecycle may seem like a daunting challenge. However, there are emerging technology and tools available to ensure security is pulled in early enough. Low code platforms give enterprises the leverage to embedded security when developing cloud-native applications, managing containers and adopting microservices-based architecture. To implement the practise of DevSecOps, low code gives the opportunity to address and improve application security across the development lifecycle.

The Window of Opportunity – How Low Code Enables Enterprises to “Shift Left” Application Security 

Low code platforms help enterprises by integrating application-level, security features such as authorization, authentication, auditability, certification, performance monitoring, and security architecture, across the application development lifecycle. By automating application-level security features, low code platforms ensure robust authorization and authentication systems that have  built-in encryption, and provide XSS and CSRF configurations to address security threats and vulnerabilities. To help developers configure security features when building applications, low code platforms provide fine-grained controls, built-in encryption options, comprehensive authentication and authorization processes, OWASP compliance support, and data protection.

While application development and deployment processes are transforming so is application architecture, which is moving from monolithic legacy systems to microservices-based architecture. With microservices, there are many hands on the deck. Enterprise applications are made into smaller components and many developers are working on different functionalities at various stages of the development cycle. At this time, when application architecture is transforming, security goals remain unchanged. In fact, the demands for application security are heightened and they need to be imbibed in the development process. Low code platforms support microservices-based architecture and enable the “left shift” of security parameters by allowing developers to configure security protocols, set privileges, and automate testing, before the application goes into production. Moreover, as enterprises leverage next-generation app delivery tools such as container technology, low code platforms help to embrace containerization at scale without disruption in existing processes and without requiring the reskilling of existing resources.

Low code’s promise is that of “Zero Complexity” DevOps Automation. It ensures minimal disruption of existing development teams, enables on-premise and cloud deployments seamlessly, automates CI/CD processes, saves on security infrastructure costs and enables DevOps teams to focus on core application needs.

If you think the “shift left” principle of pulling security earlier into the DevOps process may slow down the speed of development, think again. It shouldn’t be a trade-off to choose between accelerating application development and managing application security threats and fixing failures.  Achieving time-to-market delivery and security goals can be simultaneously achieved if you manage the DevOps process using emerging application development and deployment tools. The window of opportunity here is to streamline processes, using a sophisticated technology stack, and utilizing next-gen technology that low code offers to nurture AppSec innovation across the development cycle.

Categories
Insights

Navigating six risks of pandemic era digital transformations with low-code

By Vikram Srivats, Vice President, WaveMaker

Ensuring a successful climb out to a digital paradigm without running the gauntlet of costly delays.

The Covid-19 crisis is shifting profit pools – according to McKinsey1, the gap in economic profit between the top corporate performers and everyone else has widened dramatically. And the numbers are staggering – the top quintile of companies grew its market-implied annual economic profit by $335 billion, while the bottom quintile companies lost $303 billion, over a period from December 2018 to May 2020. Clearly, this is becoming somewhat of a winners-take-all scenario.

With acceleration of trends (e-commerce, remote work, digital) driven by the pandemic, specifically for companies with middling performance, this is a call to action to build resilient, future-ready business and operating models. And many of them are doing exactly that. During a recent quarterly earnings call, Microsoft CEO Satya Nadella said, “We’ve seen two years’ worth of digital transformation in two months.”

By now, almost every corporation gets all this.

But how do they ensure a successful climb out to a digital paradigm without running the gauntlet of costly delays and embarrassing failures that plagued many earlier corporate digital plans in fairer weather?

Beyond an array of best practices (reducing silos, no-BS decision-making, talent redeployment, shifting operations and multiplying productivity), low-code based software development has the broad capability to mitigate potential risks associated with wholesale digital transformations in these uncertain times.

First, a quick primer on low-code/no-code. Simply put, it is a visual development approach to automating software development that involves little to no hand-coding, significantly speeding up applications coming to life. With growing demand for new applications, modernizing existing/legacy applications and new platform development – and not as many software developers to go around, low-code development has gained steam over the last few years. Gartner predicts that low-code application development platforms will be responsible for more than 65 percent of all app dev activity by 2024, while Forrester expects the low-code market to represent $21B in spending by 2022. Major technology players including Salesforce, Microsoft, Google, Oracle, Amazon, Pega and ServiceNow have joined the low-code/no-code bandwagon, with deployed platforms and tools as part of their larger product portfolios

What are the risks?

But what specific risks does low-code development help navigate and mitigate?

Here are 6 clear examples:

Complexity risk – With a visual, low-code paradigm, enterprises and software providers can take quick, bite-sized chunks out of the business complexity due to Covid-19. Low-code simplifies and democratizes collaborative application development to support new workflows, increased tracking, additional procedures, shifting ways of doing business and increased overall administration – to tackle needs of remote workforces, supply chains and customers.

Schedule risk – The stakes for hitting a schedule target have never been so high. Burdening your IT with demands for critical applications, and gathering a full stack team to hand-code applications that may take weeks to deploy no longer remains a sustainable approach. Companies can instead use low-code acceleration to minimize impact from the invariable bumps (scope creep as an example) in any project, besides pandemic induced inefficiencies (lumpy productivity of 100 percent remote teams).

Budget risk – The mantra of doing more with less – specifically, more applications with less budget – is what low-code development delivers at its core. According to Gartner2, worldwide IT spending will decline by 7.3 percent this year, compared with a rise of 1 percent it calculated for 2019. Against this backdrop, low-code is exactly what the doctor ordered for companies that are making do with fractional budgets and increased oversight on spending during these times when budget overruns may be considered heresy.

Technical risk – Enterprise architecture teams no longer have the luxury of doing a double take with technology choices if their initial choices do not scale, are not secure, or simply don’t offer a solid runway from the current to the proposed future. When it comes to building enterprise applications, creating extensible frameworks goes a long way in coping with changing business needs, adding new capabilities and re-using frameworks for future initiatives. Best-in-class low-code platforms are built around modern web architectural choices and enterprise best practices, are based on open standards, generate real code that can be exported and extended, offer enterprise-class security options, and seamlessly blend-in with testing and deployment practices. Corporations using such low-code platforms have the peace of mind that they will get it right – the first time.

Talent risk – While the pandemic has disrupted the livelihoods of millions of working professionals and increased talent pools, hiring the right tech and software development talent at the right time, at an affordable price and ensuring they are productive – remains a monumental challenge. Bridging skill gaps of existing talent to scale to modern web and mobile development is not trivial either. Low-code platforms do the heavy-lifting of software development, mitigating the need for learning coding skills in a language and eliminating the need for multiple specialist roles (UI, database, backend, deployment). Low-code powered teams are inherently lean, modern-skilled, agile, full-stack development teams.

Market risk – The ultimate test of organizations wanting to climb steeply during Covid-19 is how they weather unanticipated market risks at different altitudes. With order of magnitude productivity gains, low-code powered business and software development teams quickly and nimbly dodge external risks, prototyping and producing critical-to-business applications at a pace that is near-impossible with traditional development. What it brings to the table is a quick, flexible, scalable and cost-effective approach, to accelerate development of business-critical applications and to modernize existing applications and legacy systems.

Going mainstream

In a way, enterprise grade low-code platforms were built for this moment – helping professional developers effortlessly switch to a low-code way of churning out applications in high-rate-of-climb digital projects. And helping them succeed without compromising logical granularity, pixel-perfect UI or enterprise scale and security standards.

Covid-19 may well be a temporary phase in our collective history books a few decades down the line, but this may go down as the era in which low-code development became mainstream – and a basic checkbox for corporations in a high digital attitude climb out to navigate a plethora of risks and join the winners circle.

Originally published in ITProPortal

Categories
Enterprise Application Development

Modernization with Cloud-Based Application Development Platforms

Worldwide IT spending has been substantial in the last few decades. While these legacy systems are robust, the challenge is in maintaining them and making them relevant to evolving business environments. Especially in 2020, where the priority of investment in technology is more focused on cost optimization and operations. In such times, how do you modernize and extend the capabilities of existing legacy systems?

How do you transform IT infrastructure, cost effectively?

The technology modernization journey is one that demands agility, mobility, and scalability. Given these primary business drivers and with initiatives driven by growth and transformation, there is an increase in IT spending, especially on public cloud services. The revenues from worldwide public cloud services market according to IDC totalled $233.4 billion in 2019, and the IT spending on cloud infrastructure is forecasted by Gartner to grow by 19% in 2020. What makes investment in cloud services promising is that it offers cost optimization, operational resilience and business agility.

The public cloud services market includes Software-as-a-Service (SaaS), Platform-as-a-Service (PaaS), and Infrastructure-as-a-Service (IaaS). Cloud application development and deployment services is a sub segment of this market, referred to as Application Platform-as-a-Service (aPaaS).

The Potential of Cloud Application Development Platforms

A promising proposition in the technology modernization journey

Let’s take a look at the core advantages of cloud application development platforms and how they offer cost optimization, collaboration, flexibility to utilize resources optimally, mobility, and accessibility to the latest technology and software.

  • Reduce costs and optimize computing resources – By using cloud application platforms, you do not need to invest in physical infrastructure such as servers and data centres. With the access to on-demand services and resources, you not only save millions you also reduce the risk associated with dependency on traditional computing resources.
  • Support collaboration and reduce time-to-market – Different stakeholders working on application development projects, from the developers, designers, testing experts, to the client, can collaborate using a cloud application platform. This real-time collaboration and sharing of content and components, reduces iterations, improves application development and shortens the time-to-market.
  • Utilize resources on-demand and customize requirements – In a conventional IT investment plan, there are resources that would stay idle during off-peak periods. Cloud application platforms allow for utilization of resources optimally, on-demand. During peak times, you can customize your capacity and cloud requirements, thereby saving on investment in resources, such as servers and storage equipment, which could be under-utilized during low demand periods.
  • Enable mobility and access to services on-the-go – Mobility is an important aspect of modernization. Users want access anywhere, everywhere, on all devices. Using cloud platforms, you provide your users with access to applications on several devices including their mobile phones and even using a web browser. As the platform is linked to databases and integrated with APIs, users can access services across devices at any time, giving them the mobility to function on-the-go.
  • Gain access to the latest technology and get a competitive edge – Cloud application platforms also gives you access to the latest technology and trends. Something you would have found difficult to achieve in a conventional IT system setup. By leveraging the latest technology in the market, you can increase your potential to gain a competitive edge.

Time-Sensitive and Cost-Conscious Demands of Enterprise Application Development

The potential of cloud-based, low code platforms

In the high-speed journey of modernization, enterprise application development projects have become time-sensitive and cost-conscious. Cloud-based, low code platforms address both these demands. Not only do they help you to develop applications with speed, they also enable you to utilize resources optimally, reduce development cycles, improve time-to-market rates and lower costs.

A cloud-based, low code platform, could typically be considered as a Containerized Cloud, one which comprises many instances. An instance here can be compared to host computers which do more than just storing and managing data. In a work space instance, users can develop apps independently and they each get a container which isolates their workspace from the other users. In an app deployment instance, when apps are deployed in the cloud, a separate container is allocated for each app, thereby ensuring apps are deployed independent of each other. In a platform, multiple internal services are managed and run using separate Docker Containers and they can talk to each other with REST services. Platform containers orchestrate and direct the Docker engine to perform operations such as starting or stopping a user container.

Rather than relying on expensive, one-time, customized solutions, low code platforms offer the flexibility to customize, collaborate, integrate, and deploy according to your changing requirements. The important features of low code platforms include drag-and-drop visual development, ease of integration, multi-device support, extensive customization, granular security, app containerization using Docker technology, and instant one-click deployment to private and public clouds. It’s these features of low code platforms that make them a necessary investment to address the demands of modernization in this cloud-enabled environment.

Categories
Enterprise Application Development

Evaluating low code platforms? 6 questions every enterprise must ask

If you are reading this, you are probably in the phase of considering a low code platform or you are already using a low code platform to address your application development needs.

The pace of change in technology adoption is leading to an increasing demand for cloud-ready, enterprise-grade applications. There is a sense of urgency to develop and deliver applications with speed. Application development cycles have reduced from weeks or months to days. While the promise of low code platforms is to accelerate application development with ease, not all platforms would be suited to your business requirements, scalability and application development strategies.

Despite the pressure, it’s time to pause and take stock of your existing systems and resources to identify how you can adopt technology meaningfully. Understand your business needs, your existing systems and processes, and the skillsets of available resources. To leverage the power low code has to offer, you should take the time to evaluate and choose a platform that suits your enterprise needs.

Over the years, as low code providers, we have come across some insightful questions from customers before they decided to partner with us. To understand the evaluation parameters when assessing a low code vendor, this Webinar by Deepak Anupalli, Co-Founder and Head of Product Engineering at WaveMaker will help.

Let’s take a look at six critical questions every enterprise must ask their low code vendors:

1. Is the platform purpose-built for developers? Is it easy to use and learn to build web UI or mobile applications?

  • Keep in mind who will be using the low code platform. Identify the type and skillsets of your developers.
  • Consider the capabilities the platform offers, because it should appeal to professional developers and empower them to do more.
  • Get to know what type of technology stack the platform has and if you need to reskill your existing development team.

Ideally, the low code platform should give your developers the bandwidth to focus on innovation, and the complex and critical functions that would make the application rich.

2. Does the platform support a ‘real code-behind’ strategy? Is the code generated readable and modifiable? Does it allow for interoperability of code changes across IDEs? Customization is a key aspect when developing enterprise apps with real world applications.

  • You need to know if the low code platform generates code that can be customized, modified and integrated across development environments.
  • Also consider whether the technology stack and architecture of the low code platform supports compliance requirements and existing business components. This will ensure that the applications built are according to compliance and security requirements before they are released.
  • You also must assess whether the platform supports an open standards-based technology stack, because then you can use the capabilities of mature software tools and proprietary code without having to reskill or disrupt the use of existing tools.

Like Deepak said, “You don’t have to reinvent the wheel. A low code platform that supports an open standards-based technology stack gives you the right level of maturity of software that has taken years to perfect. It also gives developers access to open standards libraries and open source frameworks like Angular, Spring or Hibernate. In this way you don’t have to reinvent the wheel in using a completely different type of software when you can get access to the same kind of capabilities by leveraging an open-standards based technology stack.”

Listen in to Our Real-World Success Stories

 

3. Does the platform help to build scalable applications to cater to larger user base or growing use cases? No application can be scalable right away. Application scalability is deep rooted into the architecture and technology used by the platform. In terms of scaling applications, modern applications use microservices-based architecture instead of monolithic architecture.

  • First, identify your scalability requirements. Are you going to increase the scope of application to include new use cases? Do you aim to increase your user base? Do you want to scale horizontally and want your applications to be deployed onto a cloud infrastructure?
  • Also get to know the architecture that the platform supports. This will help you to understand whether you can scale applications to a growing use case, larger user base or based on your data or user scalability requirements.

Listen in to Our Experiences

 

4. Does the platform have architectural best practices in place that include enterprise-grade security? Enterprise grade security has become a critical requirement. And one of the primary reasons for delay in application delivery is getting clearance for security compliance and governance rules.

  • Make sure the platform has security as a feature that is deep rooted into all the layers of the application, from the database layer, APIs, to the front-end UI components.
  • Also ensure the platform integrates with the identity management system in onboarding users and uses existing permissions for role-based information access and existing security infrastructure to secure applications.

5. Does using the platform minimize risk and maximize digital transformation efforts? One of the key aspects when using a low code platform is leveraging existing assets. To succeed in your modernization efforts, you cannot just replace existing technology, you need to integrate them with existing systems and create modern workflows and processes.

  • Make sure the platform has built-in integration features that allows for integration with REST APIs and SOAP web services and existing systems.
  • Also make sure the platform can generate all data structures and methods, and enable developers to manage integration and configurations without the need for them to write custom code.
  • The platform must also democratize application development to enhance existing skills across teams, thereby minimizing risk and dependency on skills.

6. Is the pricing or licensing model scalable and affordable? There is a lot of confusion and complexity in understanding of licensing models of different platforms, especially when you want to build more applications.

  • Identify the right pricing model and strategy that fits your needs, one that is not short-sighted. The licensing and pricing model should be affordable and scalable for your application use cases.
  • The platform cost should not be disproportionate to your scalability needs. Whether you are building a complex application, increasing your user base or expanding your business use case.

Nothing holds truer today than the statement by Marc Andreessen that “software is eating the world”. In the last decade, software development has rapidly evolved and there is an increase in cloud and mobile adoption. The increasing change in pace at which software is getting delivered is faster than what enterprises and users can keep up with. Given this fact, it can only mean that it’s time to pause, assess and improve the technology you have to deliver more with less.

When assessing a low code vendor, to understand the evaluation parameters and find examples of how low code can deliver value, you can get a first-hand perspective in this Webinar by Deepak Anupalli, Co-Founder and Head of Product Engineering at WaveMaker.

 
Categories
Enterprise Application Development

Is your low code platform truly scalable?

In 2020 there are 2.7 billion smartphone users and counting. 90% of their time on these devices are spent on apps. This is just mobile applications, there are also web applications used on the desktop for personal and professional purposes.

With the increasing number of app users, developing applications at scale has taken precedence in the market today and low code platforms are leading the evolution in application development. And these are not just ordinary applications that users demand, companies also need enterprise-grade applications that provide high performance to meet their business needs.

At a time when application development is in demand, high performance and massive scaling are primary business drivers. From an IT Leader’s point of view, it’s about speed, performance and business continuity. How fast can applications be developed cost-effectively? How to scale applications to meet the demands of business users? How can modern applications be developed to transform and complement existing legacy systems, without disruption?

At the rate at which apps are consumed, the questions arise. What is the breaking point of the applications that your enterprise can build? How scalable is the platform on which your applications are developed? Is the low code platform you use truly scalable?

While low code platforms have taken a front seat in terms of scalability, only those platforms thrive that can manage variable workload, support multiple developers, provide resilience in service availability and sustain user experience in production. Only if all this can be achieved by the low code platform you choose, can it prove itself to be truly scalable. To find out if your low code platform provides scalability, whether it is dev-time or run-time scalability, use this simple checklist.

The best way to extract the real value of your low code platform, in terms of scalability, is to make your internal processes and architecture design aligned to your scalability needs.

Meet demands with capacity planning. Scalability is all about adjusting capacity to meet your demands. It is important to first identify the number of developer logins and app deployments permitted on the platform, based on your license terms. For instance, you may have the infrastructure capacity to develop and deploy applications but it may be restricted by your license terms, and vice versa. When setting up, find out the platform capacity and know if it suits your scalability needs.

Use an architectural design suited for enterprise scalability. AD&D teams spend a lot of time to manage, validate and fix large application systems that use different architectural designs. To save time, make teams more agile and create reusable applications at scale, choose low code platforms that are built to have a microservices architecture model, as it provides the required scalability.

When evaluating a low code platform ensure that applications built on the platform follow modern application architectural models. A truly scalable low code has well-defined REST APIs that separates the UI and the backend layers, allowing for developing applications at scale and ensuring that the best practices in terms of performance and design are followed as per industry standards. Ideally, the low code platform must have fast API creation and binding tools, with automated API documentation, to help you re architect your monolithic, legacy applications to modern, microservices-based microapps.

Streamline operations for faster deployment. The premise of scalability also revolves around the ability to deploy applications with speed. By using a low code platform that has containerized application delivery, development teams can ensure faster deployment, streamline operations, increase scalability, and portability. With cloud-centric applications pivoting on the scalability factor, low code platforms that use the Docker containerization model provide a resource-optimized environment that ensures deployment to cloud providers and Kubernetes. Moreover, those platforms that provide auto-containerization also power microservices-based deployments at scale.

The increasing demand for applications today has led to large-scale deployments, which need to have low response times for high concurrent requests. What makes a low code platform truly scalable is when it is built to use architecture that is stateless, one that allows to develop applications at scale for deployment on container-based systems. When addressing the demand for massive scaling of applications, the best way is to align your internal processes and architecture design to the low code platform you choose.

Categories
Enterprise Application Development

Has your low code platform still got you locked in?

Has this happened to you? You want to build an application within weeks. You find a low code platform that allows you to build an application with speed, using only a small team of professional developers. After building a custom application you decide to move to another platform. That’s when you realize you are “locked-in”!

The low code platform you used generated proprietary code and it required a subscription to run applications independently. You have problems with data access and control, as the platform uses proprietary technologies, and code maintenance and access to libraries is a challenge.

Being “locked-in” is a challenge many developers, architects, and application teams face while using or moving applications in different platforms. To address this challenge and understand the extent to which you could be locked-in you need to first ask some of these questions:

  • Are the applications built on the platform independent?
  • Can applications run without dependencies or do you need a subscription?
  • Is the platform open and flexible to allow two-way IDE interoperability?
  • Does the platform provide a simple way to access and export data?
  • Does the platform help to easily create, share, and consume APIs?
  • Does it offer an open-source runtime library, making deeper customizations free from lock-in?
  • Is the pricing and licensing option future proof?

Lock-In is Not Binary. It’s not Black and White.

In Gregor Hohpe’s book, The Software Architect Elevator, he talks about how modern ‘elevator architects’ are instrumental in aligning organizations and technology, reducing friction, and charting a transformation journey. When they ‘ride the elevator’ from the penthouse (where business strategy takes place) to the engine room (where technologies are implemented) they understand that the common attribute in system design like lock-in is not binary, it’s not black and white.

The attributes of a “lock-in” come in different dimensions, in the form of a platform, code, or vendor lock-in. The approach to understanding lock-in cannot be in an all-or-nothing manner. It needs to be considered across the application development and deployment lifecycle, at a broader level in terms of business / vendor, platform, and code lock-in. And while the seductive proposition of low code is to build applications faster with leaner teams, you need to consider the different dimensions of a lock-in to unlock the real value of low-code.

The Real Value of Low Code is How it Addresses Different
Dimensions of a Lock-In

Platform Lock-In. Can you run applications on infrastructure of your choice?

Once you build an application, the question is does the platform allow you to run applications on infrastructure of your choice, on-premise, private or cloud? How certain are you about the cost of running your applications in say a year or five years from now? To avoid being locked-in to a low code platform, you must consider how your applications will be run in the future, on what type of infrastructure, and other aspects of accessibility, scalability, and portability.

By supporting hybrid and multi cloud app deployments, low code platforms allow running of applications on infrastructure of your choice. With the increasing importance of delivering and deploying applications on cloud infrastructure, you can lower infra TCO by leveraging container technology. Docker containerization helps you to manage your IT app infrastructure, faster than VMs, enabling portability of workloads between cloud vendors. Low code platforms that support cloud-native architecture, and have auto-containerization and application delivery integrated, can help you seamlessly deploy and scale applications on infrastructure of your choice.

Code Lock-In. Can the auto-generated code be extended and customized?

You could get locked-in to a platform in various ways, from proprietary application-level services to control over associated access rights. Moreover, when shifting platforms, exporting and re-importing projects is a tedious affair. With the need to copy-paste code, it makes the development process time-intensive and error-prone.

Given that the majority of the code is auto-generated by a low code platform, the quality of code, the flexibility to extend and customize is something development teams need to be particular about. Taking a developer-centric stance, low code platforms adopt a standards-based ‘real code-behind’ approach. This provides extending code in the future and interoperability of code changes across inbuilt editors and external IDEs (Eclipse, IntelliJ).

Distribute applications freely without concerns of being lock-in to vendor-specific frameworks. The low code platform you choose must be built on an open-standards based technology stack, one that allows you to distribute applications without licensing concerns, and without a lock-in to vendor specific frameworks.

Write and extend custom code in an IDE of your choice. Another aspect of a code lock-in arises when you need to build applications on one platform and use it on a custom Integrated Development Environment (IDE) of your choice.

To optimize application lifecycle management, low code offers a unique development experience. The IDE sync feature in low code platforms enables you to mix-and-match custom code written in an IDE of your choice, such as Eclipse or IntelliJ, with the platform components.
To know how you can seamlessly sync project changes between our low-code platform and the IDE of your choice, check out The Studio WorkSpace Sync Plugin. Using this plugin, you can pull the latest project changes made on the platform and ensure they are applied to the IDE code, you can push IDE changes to the platform, and synchronize projects.

Keep in mind that when switching vendors, you are also moving to a new product. You could be locked-in to a product because it becomes difficult to release new features, manage updates, make heavy customizations, configure integrations and setup proprietary extensions.

A low code platform allows deeper customizations using custom methods and extensions accessible from frameworks, without being locked-in to a product or the platform. With access to an open-source runtime environment and libraries, a low code platform uses popular frameworks used by millions of developers, making it easier to make customizations and avoid a product lock-in.

Synchronice and track code changes with version control systems. Most development teams also face the challenge of tracking and updating code when version upgrades happen. Every time a version is released, most of the times applications need to be rewritten to maintain the existing extensions and customizations built.

To synchronize changes and track code changes, low code platforms offer version control services. By using an inbuilt version control system (VCS), you can manage changes to your projects files, including source codes, documentation and web pages. Low code platforms provide an integrated version control system where you can configure external VCSs such as Gitlab, Bitbucket, and Github.

Business or Vendor Lock-In. Is the licensing and pricing option future-proof?
A business or vendor lock-in is typically what IT teams mean when they say ‘lock-in’. This type of lock-in could happen when you are switching from one vendor to another. Commercials such as support agreements and licensing that you sign up for could get you locked-in to one vendor.
To avoid a business or vendor lock-in, begin with asking whether the pricing suits the requirements and size of your enterprise and if it is future-proof when you want to scale in the future.

Software development platforms have always had some type of proprietary nature embedded. With open source technology like low code, this has changed. Low code platforms take an extensible approach to application development and delivery, one that supports open source technologies. That being said, when evaluating a low code platform, you need to be aware of not getting locked in to the ‘abstraction’. The abstraction of code extensibility, data accessibility, flexibility to customize, and freedom to track and manage components in the application development and deployment process.

How you use your technology will determine its success. Be aware of the types of lock-in.

 

Unlock The Real Value Of Low Code

Categories
Insights

How a Low-Code Platform Can Improve Your Enterprise Application Development Strategy

How many applications are used in your enterprise? Be it a messaging application, project management tool, virtual meeting software, or HR application, critical enterprise applications have become the lifeline of business operations.

As enterprises become more hyper-connected, the virtual workplace and marketplace has transformed into a complex ecosystem. It has become an environment that demands seamless interaction, collaboration, and communication between people, applications, and devices.

While traditional organizations are accustomed to working in silos, the age of agility is driving them to bridge these gaps. The foundation of an agile organization is about enterprise-wide collaboration, bridging silos, the autonomy of cross-functional teams, alignment with business and application strategy, and self-driven teams that focus on innovation. The agile model in theory is a great concept. Implementing the concept, however, is a challenge many enterprises find difficult to address.

To achieve enterprise agility, it helps to have a low code platform as a part of your technology toolbox. What low code offers is an environment that empowers teams with specialized skillsets to innovate, encourages collaboration to ensure quick turnaround time of ideas to apps, automates processes to ensure optimum resource utilization and allows for deployment at scale.

Accelerate the idea-to-app turnaround time. Accelerated application development and delivery is a primary factor in agile development. Low code platforms provide a visual development environment, auto-generates code, enables code-customization and extensibility using prefabs, provides the flexibility for 2-way workplace sync with IDEs, and allows for complete integration with CI/CD pipelines.

Empower development teams to innovate. There is a lot of time spent by development teams in manual coding under traditional application development. With low code application development, code is auto-generated, it is extensible and can be customized to build applications at scale. By using visual drag-and-drop features, low code helps to build core applications, giving development teams the time to work on complex components of applications.

Create leaner and agile teams. Typically, traditional development teams are made of different types of profiles, from professional front-end developers, back-end developers, UI designers, UX experts, database developers, DevOps, to quality analysts.

By providing access to full-stack technology, low code helps to create leaner and agile teams. You can reduce the dependency on specialists, encourage upskilling, focus on business logic and drive innovation because the low code platform can take care of end-to-end application development and deployment.

By providing auto-code generation, integration with existing applications using smart API integration tools, auto-generation of DB schema, and auto-containerization for seamless deployment, low code streamlines development teams, making them leaner and agile to address the hyper demands of application development.

21st century IT leaders recognize the importance of agility. At a time when the market and workplaces have moved to virtual realms, there is a greater emphasis on seamless communication, collaboration, and coordination. The premise of enterprise-grade low code platforms is the ability to provide an environment for innovation by automating manual processes and to create leaner and agile teams by empowering them with a modern technology stack. This is why low code has become mainstream and why it is considered to be a technology that is future-proof.

Originally published in Inspirationfeed

Categories
Insights

Future proofing traditional Java programming teams with low code

Enterprise needs today have become more demanding. The new sense of urgency, to evolve, to modernize and drive mobility, scalability, and flexibility has led to enterprises embracing a ‘digital first’ approach and adopting new technology extensively. While this translates to reinvention in the way of working and the use of technologies, it does not mean that every aspect of the business needs to be reinvented.

Old systems and skills, that have stood the test of time, need not be discarded altogether. Instead, upgrading systems and updating skills can help to meet new enterprise demands with old tools and can result in easier implementation and better ROI on IT investment.

A relevant example of how emerging technology is combined with conventional tools is the use of low-code platforms with traditional Java programming in application development. Twenty years on and many enterprise servers are still using the Java programming language and successfully running Java-based, mission-critical applications. The fact that Java is still being used speaks of its evolution and effectiveness in addressing enterprise demands even in the age of cloud computing and container technology.

When creating application development strategies, there is often a debate about whether low-code should be preferred over traditional Java programming. However, this is not an “either / or” decision. While low-code platforms are designed to provide core functionalities, with the help of experienced developers customization and specialized functions can be added to applications. After all, a low-code platform is ultimately built on a programming language like Java.

With low-code platforms gaining momentum, the role that traditional Java programming plays cannot be ignored. By combining old with new technologies, here’s how the micro and macro levels of application development can be covered to meet new enterprise demands.

Give developers the bandwidth to innovate

In certain application development projects, combining low-code with manual coding helps developers spend more time on complex functions. As the low-code platform can be used to create core applications rapidly, developers can focus on critical specifications to make the application rich.

Build apps that support multiple device ecosystems and operating systems

Enterprises today need to build applications that can run on different operating systems and devices. Such an ecosystem requires application development using neutral languages and coding for specific parts of the application that have distinct functionality.

Java development teams have to make an enormous effort in manual coding to create modern applications that work in dynamic environments. Here’s where low-code platforms help by enabling developers to duplicate core functions of applications that can work across devices and environments.

Ease the application maintenance process

Specifications of IT hardware and software are changing more frequently than before. As the technical requirements constantly change, relevant modifications to the code is necessary to ensure the app functions. When enterprises rely entirely on traditional Java development teams, manual changes in code makes app maintenance a tedious affair.

App maintenance can be made easier by using low-code platforms. Using visual development interfaces and modular components, low-code platforms manage and maintain applications in the backend giving enterprises the time to focus on the design and critical functions of the application.

Streamline the application deployment process

Deployment of applications is a complex process because every line of code needs to be tested in a lab environment, and trials to ensure multiple app instances function in specific configurations needs to be conducted. Testing before deployment requires intensive manual programming and its complexity makes it a time-consuming process.

With pre-built modules, low-code platforms help to test app functionality before their release. With the actual development and production environment accessible in a cloud ecosystem, testing and deployment using low-code is simpler and faster.

To optimally utilise the skills and experience of development resources, enterprises need to combine the technical strength of traditional systems with the speed, agility and scalability that modern technologies offer. By combining the old with new technologies, not only can applications be developed, maintained and deployed faster, rich applications can also be created by allowing traditional development teams to give the required attention to detail.

In a market environment where change is constant and the future is uncertain, future-proofing seems to be the safest way forward. Stay relevant to stay ahead by upgrading your legacy systems with a modern low-code platform. Find out how our low-code platform can help you adopt new technology meaningfully.

Originally published in TECHGYD.COM