At MercuryWorks, we use React regularly in front-end development because it offers key benefits to both end users and developers. The open-source JavaScript library React JS was first created and implemented internally at Facebook in 2011. Since then, it’s dominated other libraries and frameworks like Angular JS and Vue JS in popularity with a current average of 10 million monthly downloads.

Sophisticated JavaScript libraries are critical to delivering powerful modern web and mobile applications with optimal UX/UI, and React checks the boxes that we need to create the mission-critical applications our clients depend on. React is the dominant front-end framework because it offers modern benefits both on the developer and the user side.

Here’s why and when we opt for React application development, and why we recommend that companies consider React when they’re in the market for an app development solution.

1. React Is Easy to Use and Maintain

Any front-end developer familiar with JavaScript can easily learn and use the React library. As a collection of reusable UI components, React reduces technical debt and opportunity for coding errors while delivering beautiful, lightweight user experiences.

There’s been some healthy—if pedantic—debate over whether React is a library or a framework, and the answer is… yes. As a library of components, React is architecture agnostic; it can be built on top of any backend. But it’s also positioned as an interface-only framework as it’s “a way of doing things” in front-end development with a prescribed structure and requires some inversion of control.

React is flexible, nimble, and fast loading, and its colocation of content, logic, styling, and state control greatly simplifies the maintenance load and keeps code interdependencies to a minimum. Upgrading and building components is easy in React’s modular structure, which minimizes the possibility of disrupting your code base and maximizes stability. This translates to application development and maintenance consistently coming in ahead of schedule and under budget.

One of React's benefits is the availability of thousands of UI libraries and resources

Interested in React Application Development?

Let’s Talk

2. React Offers Beautiful, Extensive UI Resources

Mission-critical applications depend on a smooth, highly interactive interface, which is precisely what React is designed to deliver. The prevalence of resources such as third-party developer tools and literally hundreds of UI libraries makes finding components for application use incredibly easy—and prevents teams from having to reinvent the wheel when it comes to common interactive components such as buttons, menus, dropdowns, graphs, and more.

The benefits of an interactive UI is exactly why applications that require a high degree of seamless interaction—like Netflix, Instagram, and Salesforce—are built on React. 

Salesforce is built on React for the advantage of its smooth, interactive user interface.

3. React Delivers Strong, Robust Performance

Power and speed are essential to a great user experience, and React’s simple rendering logic allows developers to create more without weighing down the application. When implemented with server-side rendering, React significantly decreases both perceived and actual load time and allows the application to be crawled by search engines. Both of these outcomes contribute to better UX and better results in technical SEO.

What’s more, React’s innovative Virtual DOM (VDOM) makes it a game changer for front-end development and for a better, faster user experience on highly interactive web applications. React JS uses the Virtual DOM to monitor which parts of the DOM to update selectively based on user interaction, rather than requiring the entire page to reload. Not only does this provide a smoother UX for users, but updating the Virtual DOM is faster and more efficient than manipulating the DOM itself. This translates into less computing power and better memory optimization, as well as simpler code.

A developer tool featuring React, which offers benefits to both end users and developers

Interested in React Application Development?

Let’s Talk

When We Recommend the Benefits of a React Application

The benefits above make React a go-to solution for many different types of applications, but there are a few where it’s objectively the strongest contender. Typically, those use cases are where high interactivity is the nature of the application, and thus where the Virtual DOM and/or React’s server-side rendering are essential to providing the best user experience:

  • Data management. Heavy data management applications such as CRMs, resource management, and analytics platforms that contain a large amount of data that users may need to manipulate (such as filtering, sorting, and adjusting views) very quickly.
  • Single-page applications (SPAs). The “classic” manifestation of a single-page application is a social network—hence Facebook’s development of React as a framework and the fact that it currently uses more than 50,000 React components. Today, however, many web applications rely on native-like interactivity without the cumbersome UX and extra time and power required to load additional pages. Many popular SPAs were built with React, including Netflix, DropBox, and PayPal.
  • Cross-platform applications. React is also a flexible option for situations where you need both a native mobile application and a web app. While React JS is a library and React Native is a mobile framework, much of their architecture is the same. Developers can easily shift to React Native while designing and building a mobile application, and it’s used for both Android and iOS.

Choosing a React Development Partner

Ultimately, React JS is an incredible tool that helps web development teams deliver quality code faster—without setting themselves up for increased cost or avoidable technical debt. React JS comes up frequently in the discovery and consultation conversations we hold with our clients, particularly when their mission-critical applications require high interactivity and powerful performance.

Interested in React development services for your organization? We use React regularly to build applications with quick response times, smooth interfaces, and native-like performance. 

Interested in Learning More?

Fill out the form below and our team will follow up shortly.

"*" indicates required fields

For several years, low-code solutions like Microsoft’s Power Platform have empowered “citizen developers” to build impressive and effective solutions to their business problems. One of the Power Platform’s advantages (and reason for existence) is to put powerful software development in the hands of non-traditional software developers while shielding them from the complexity that comes with full-code software development.

But a funny thing happened on the way to the rollout of democratized enterprise software: many of the standard application lifecycle management (ALM) practices were lost in that process. Microsoft is now bringing many of those ALM powers to bear in the Power Platform.

What Is Application Lifecycle Management?

Application lifecycle management is defined as the tools and processes that manage the lifecycle of an application from conception through release and retirement. Adopting ALM is also closely associated with the continuous delivery of software with frequent releases (sometimes as often as several per day) as opposed to releases and updates only coming every few months. Application lifecycle management provides a framework for software development and ensures that every team member knows the Who, What, When and Why of any changes made during the development process.

Why Application Lifecycle Management Matters

If you are a software development professional coming from a full-code background, you are accustomed to several application lifecycle management practices and tools. One is a progression of infrastructure environments to move code through each release—dev, testing, staging and/or production (names will depend on your shop).  These distinct environments enable you to run continuous integration and testing in a low-risk environment (dev/testing), perform internal checks and elicit stakeholder feedback (staging), and release for real and high-volume use (production) when it’s ready.

This staged release mechanism enables software developers to have a test data bed (remove personally identifiable information, etc.) while keeping production data clean.  Separation of environments is also very important to make use of dev/testing values for things like emails and transactions (i.e. test credit card accounts) in non-prod environments for low-risk end-to-end testing. If you’ve been in the game for a while, you have become dependent on these powers. Without them, you are carrying out a lot of careful manual adjustments to achieve similar results—or you’re at risk of becoming the next “test in production” meme.

Does ALM Have a Place in Low-Code Development?

Traditionally, low-code tools and ecosystems have not had an ALM story, which has been viewed alternately as a feature and a problem: 

  • It is a feature because with low-code development you don’t have to be pestered with such things as formal deployments, formal QA, etc.  You can just do your thing and roll it out— and that is exactly what most low-code developers do. 
  • It is a problem in the sense that even though low in code, these solutions carrying out enterprise and important jobs have to be right (not just “kind of right, not bad for a non-developer”). I’ve already played my hand, but MercuryWorks believes that ALM does in fact have a place in low-code development.

ALM for Power Platform: Two Approaches

As a leading low-code platform for developers, Power Platform makes an ideal backdrop for reintroducing application lifecycle management practices. There are currently two ways to apply ALM here: build your own features into Power Platform or use Power Platform Solutions. 

1. Roll Your Own Low-Code ALM

Prior to having formal ALM facilities built into the Power Platform, low-code developers were forced to roll their own supporting features in their solutions. The following is an example of a “Test Mode” that we have built into Power Automate flows in order to provide a lever to place a process into non-production mode (and handle notification emails accordingly).

Simply put, we create a Boolean variable that determines whether or not the flow is current in Test Mode along with a variable to track the identity of the tester.  This status flag and tester identity tracker can be used to great effect with a Flow in production use to operate as normally but include additional messaging and logging to testers/support staff.

 

A DIY application lifecycle management

Workflow within DIY "test mode" for application lifecycle management in Power Platform

With this strategy in place we can then use these values to either use custom “Condition” blocks that hinge on the Test Mode variable or cc: support staff (based on the value set for Tester Email Address) such as in this example (if not in test mode the null email address will keep anyone from receiving extra emails):

Application lifecycle management notification email

2. Power Platform Solutions

Luckily, as the low-code ecosystem evolves, it has moved into a maturation phase which has brought capabilities like ALM with it. Solutions are Microsoft’s mechanism for implementing application lifecycle management (ALM) in Power Apps and other Power Platform products, such as Power Automate.  

Initially rolled out for non-production environments in mid-2021, at this time Solutions remain in Preview mode which brings with it a few caveats:

  • They are not supported by Microsoft Support
  • Functionality may be missing
  • They are not meant for production use

For the above reasons, Solutions is a feature you may want to dive into, utilize for internal non-essential systems, and generally build capability with until they are removed from Preview mode.

Implementing Power Platform Solutions for ALM

Here are a few features and considerations to keep in mind as you leverage Solutions for your own application lifecycle management in Power Platform. Keep in mind that Solutions remain in Preview Mode and are not yet meant for production use:

Create Your Power Platform Environments

The first step in accruing the benefits of diverse environments and the classic dev-staging-prod lifestyle within Power Platform is to create your desired Environments.  As you would expect, this capability is found in the Power Platform Admin Center (this used to be restricted to Dynamics 365 admin).

A Power Platform Environment is a space to store, manage and share your organization’s data, apps and flows.  It also serves as a container to separate apps that may have different roles, security requirements or target audiences. When users create an app, they place it in an environment and then that app can connect to any object within that Environment.

Power Platform Environments

Power Apps and Power Automate automatically create a single default Environment for each tenant. If you have not had reason to experiment with Solutions to date, your tenant most likely has that single Environment.

Microsoft has published full details on the steps required to create an Environment, but the following screenshots illustrate the environment creation process:

Creating a new environment in Power Platform

Production Environment in Power Platform

2. Get Hands-On With Solutions

Now that we are armed with multiple environments, you can begin to capitalize on the benefits of Power Platform Solutions.  Solutions are Microsoft’s main mechanism for implementing Power Platform application lifecycle management, most notably in Power Apps and Power Automate.  

Solutions are used to transport apps and components from one environment to another or to apply a set of customizations to existing apps. This means that a solution can contain multiple apps and objects (tables, processes, web resources, choices, flows and more) that are all involved to solve a business problem.

Within Power Apps and Power Automate, you can view a list of solutions by selecting Solutions in the left navigation.  Note that because Solutions are still in Preview mode that you need to enable the “Solution preview on” toggle in the admin center.

What’s this look like?

List of solutions for application lifecycle management in Power Platform

Clicking on any solution in the overall list will drill you down into the objects contained within that solution.

If this as far as you choose to go with Power Platform ALM, the flows and apps you have placed in a solution will continue to work just as if you had constructed them outside of a solution. The only difference thus far is that rather than seeing your flows in the standard “My flows” tab (for example), you will need to drill into the relevant solution to access and modify the flow (or app or table, etc.):

Connection References, Not Connections!

A key ALM element that Microsoft added to Power Platform Solutions is that of connection references rather than direct connections.  

Microsoft’s official definition of a connection reference is “a proxy or a wrapper around an API that allows the underlying service to talk to Microsoft Power Automate, Microsoft Power Apps and Azure Logic Apps.”  In other words, instead of providing credentials for a connection to a service like Teams or Outlook.com, you make connection to these services via a reference that can change across environment.

Connection references manifest within each environment as a challenge for credentials that is applicable to only that environment. In this way you can have a developer user account to access connected services in a dev environment but use a system account as the connection authority in production.

Environment Variables

Environment variables are another new key Power Platform ALM mechanism.  An environment variable can be created manually in the Solutions portal interface (or if you’re fancy you can also do so in code).  A variable is managed within a specific Common Data Service entity and can be accessed from any Power Platform solution element.  That means, for example, an environment variable for “Admin Email” can be accessed by any Power Automate Flow within the same solution.  A variable can be one of the following data types: text, JSON, decimal number, “two options” (true/false), data source or secret.

Environment variables should be used to store configuration data specific to environments, similar to the DevOps pipeline practice of using environment variables in a build script to provide database connection strings applicable to dev, staging or production. 

When used properly, the environment variables can avoid storing environment-specific/dependent configuration settings anywhere in a Power App or Flow.  Instead, any solution component can reference environment-specific information such as URLs and configuration parameters.

We’re not done!  We have more coming in our next post: exporting solutions, migrating solutions across environments, and some Solutions gotchas.  Stay tuned.

How to Manage an Effective Digital Transformation in Changing Times

Tech leaders are facing new challenges in 2022: more pressure than ever to keep systems thriving in the midst of huge technical demand… and the threat of losing the skilled labor required to do it. In this exclusive series, we’ll share some key takeaways to help tech teams stay agile:

  • Why digital transformation is an insurance policy against attrition and change
  • How to identify and manage the technical debt that threatens employee productivity and fulfillment
  • How DevOps practices can liberate and improve tech teams
  • The playbook we use ourselves at MercuryWorks to create painless digital transformations for our enterprise clients
strategy planning for a custom application

Investing in custom application development for your business is an important decision, and it’s even more important to choose the right development partner.

With thousands of firms in the market and even more freelancers, it can be difficult to tell the difference between a team that’s lacking and another that’s legitimate and able to deliver the quality your company needs for mission-critical operations.

But there are some criteria that you can use to evaluate the strength of your application development candidates. Having a set of guidelines can be helpful as you interview and weigh potential partners based on competency, business practices, and the ability to add strategic, expert value to your project.

Here are nine qualities that you should look for. 

1. Good Match to Your Tech Preferences

If your tech team prefers to work with a certain tech stack, you’ll want to find an application development partner that is well-versed in those technologies and has the expertise to fit your needs. Beware of potential partners who don’t specialize—it’s a good sign they’re outsourcing your project to whoever they can find to do it and may not have the depth of knowledge they need to execute efficiently or deliver a high-quality product.

But the other end of the spectrum is potentially problematic too: firms that offer only one solution as a “one size fits all” approach to every problem. A hammer looking for a nail may miss potential opportunities for optimizing performance and functionality.

Your partner should have enough diversification in technologies that it’s well equipped to make strategic suggestions that will improve the final product, even if they’re not currently present in your tech stack.

A selection of the custom application development technologies used at MercuryWorks

2. Proven Application Development Experience

Any potential partner should provide no doubt that they bring a wealth of experience to your development project. It should be clear that they have done the type of engagement you are looking to do many, many times. While they likely haven’t built the exact application you’re looking to develop (after all, this is custom development), their work experience should reflect expert working knowledge of key components of success in your software.

One way to vet that is to review case studies, testimonials, and links to previous projects. When evaluating the firm as a potential partner, you can glean a lot from the quality of the case study—including how well they were able to understand their client’s challenges and specific needs, as well as the quality of the finished product.

But to go even deeper, make sure that your potential development partner is willing to provide you with references. Speaking with past and current clients will give you the opportunity to ask questions. Unfiltered, open conversation that will allow you to really find out what went smoothly and what didn’t and how both parties worked together to solve it. How flexible and adaptable was the firm? How communicative and responsive to their clients’ needs? You’ll gain a more accurate sense of the working relationship and what you can expect from the development firm in the future.

3. Multidisciplinary Expertise

If the team is comprised of employees, it’s also good to ask about their knowledge and skill sets. Is it a team of generalists who know a little about a lot, or are there experts in specific areas across the organization? Are there dedicated front-end and back-end engineers? Infrastructure specialists? DevOps engineers? UX/UI designers?

A team of specialists will possess the skill sets to develop creative solutions to your and your users’ problems and be better equipped to work through potential challenges that may arise during the development process. Expect a large difference in quality when you transition from working with generalists to experts in their field.

Considering a building a custom application, but not sure where to start?

Get our Ultimate (Non-Techy) Guide to Building Custom Software:

4. Developers as Employees, Not Subcontractors

It’s not uncommon for development firms to hire subcontractors to execute on their projects. It’s cheaper to hire ad hoc, and they can expand or reduce their staff according to their client load. Many even use offshore labor. But it’s generally not a great customer experience and it doesn’t lead to high-quality work product.

Why?

  • Consistent, reliable outcomes come from employing and investing in training developers on staff. This provides more continuity for projects throughout the lifecycle.
  • Full-time employment allows the firm to set and hold employees to standards and best practices and invest in professional development. Their team can grow their skills over time and stay abreast of new trends, which benefits your custom development project.
  • Having the same team that built your original custom application also building new features and functions down the line is more efficient and cost-effective.

5. Frequent, Transparent Communication

In custom application development, look for a partner in the process. You should expect collaboration and open communication around work progress, questions, and changes in the delivery schedule. Any firm who brokers in “black box” development without providing insight into the product lifecycle is not a good fit.

Too many clients have to find out the hard way, investing thousands of dollars into a project and getting burned in the process when it goes over time and over budget without a clear explanation. It becomes very hard to know who to trust.

At MercuryWorks, we’ve developed several ways to keep our clients apprised of their project’s status:

  • Clients can see progress firsthand in demos completed at the end of every two-week sprint.
  • We developed an extranet specifically for clients to login and see the progress of their project, work completed to date, work that still needs to be done, project spend to budget ratios, and more.

It’s not common for many development partners to offer this level of transparency, but we find that it brings value and peace of mind. Our clients can trust as much as they’d like and verify as much as they need.

6. Strong DevOps Culture

DevOps is a system of practices that makes application development more efficient and improves product quality. From best practices for maintaining code repositories to managing complicated projects, DevOps has evolved in the past decade from eliminating bottlenecks to creating a pipeline for continuous delivery and improvement.

What does this mean for clients? A development partner with a strong DevOps culture and proven experience tends to produce better, faster results up front, which ends up saving you time and money. In addition, a continuous pipeline for release management enables ongoing support after release, reducing the amount of technical debt that your team might otherwise incur from a firm that releases a product manually.

7. Investment in Your Product Vision

Product vision is what separates a strategic partner from a simple order taker. They will help you think through your users’ needs. Your custom application development team should begin by attempting to gain a deep understanding of your users and their needs, as well as yours.

In fact, it’s not uncommon (and good business practice on both sides) for the work agreement to take the form of two independent contracts: one for discovery, planning, and assessment, and a second for the actual development.

strategy planning for a custom application

The discovery process should involve your partner gaining a deep understanding of your business and assessing your challenges before making a recommendation. Being able to view your product from a business perspective instead of just a tech perspective is vital to creating an application that meets your needs.

It also enables your application and your relationship with your partner to contribute increasing value after launch—so that every activity from hosting, managing, and maintaining the application to investing in ongoing product development is accomplished with your product vision at top of mind.

8. Commitment to Knowledge Transfer

One of the greatest differences between a mediocre development partner and a stellar one is an expectation for a long-term relationship based on open sharing of knowledge. It makes no sense to pay for a firm to develop an application, only to have them “hold the keys” when it comes to knowing how it’s built and how to maintain it.

A good partner is more than a good developer—they’re a teacher and a guide who is committed to your success:

  • They should work to empower your team and share how the application works inside and out.
  • They should be willing to codevelop with your team, if desired.
  • After release, they should be equipped to assist with onboarding and support for as long as you’d like and have the organizational infrastructure for doing so professionally.

9. Custom Application Development Should Feel Right

While there may be many firms out there that can handle your technical challenges, that doesn’t mean that they’re all a good fit for you and your organization. Pay attention to how the firm is engaging with you and your team. Are they professional in how they do so? Do they get back with you in a timely manner? Are their communications clear?

These are important questions to ask yourself while engaging with a prospective partner. Having the right fit for your organization’s style and preferences will go a very long way towards a successful long-term partnership.

MercuryWorks has solved wicked problems for hundreds of clients and has developed many long-standing relationships based on trust, customer service, and quality. With more than 20 years of experience in software development, we consistently ship custom solutions that closely align with business needs and continue to work with clients for their long-term, ongoing, evolving support and development.

Interested in an application development partner for your organization?

Fill out the form below and our team will follow up shortly.

"*" indicates required fields