Gartner defines the product development lifecycle as the end-to-end process of designing, developing, testing, and launching a new product or service. For the effective transformation and maintenance of any idea in a product development lifecycle, it’s critical to follow a systematic approach to prioritizing investments in product and customer experience. You also need to integrate insights and best practices to maximize product management efforts, to improve the effectiveness of the product and engineering relationship.

A well-thought-through product lifecycle management can lead to.

• Informed decision-making at every stage of the development process
• Increased ROI
• Improved profitability
• Development of an effective marketing strategy
• Building a roadmap to make the product appealing and improve customer loyalty

The End-to-End Product Development Lifecycle

As we saw earlier, while the entire product development lifecycle can be divided into a few logical steps, in reality, several considerations at each stage can make or break the process. Therefore, getting them right every time is critical. This is where product engineering can play a key role.

Product engineering is an essential component of the product development lifecycle. It involves creating the product’s technical specifications, which serve as the foundation for the product’s design, development, and testing phases. Without proper product engineering, a product may not meet the requirements of the market or fail to meet the business’s goals.

Let’s look at the steps involved in product engineering.

Step 1. Ideation and Roadmap: Idea generation may or may not be the first step. What we mean is, there may be no great ideas for a product and its features or too many ideas that make focusing and planning the whole process a challenge. In either case, it is best to.

• go back to the customer problem the product aims to solve
• list out features based on recommendations
• assess them based on the value they create
• evaluate the time needed to develop those features
• understand the complexity involved, and
• shortlist features that are a must-have and can be developed quickly.

One of the advantages of agile development is that the first release does not have to contain all the features. It can be upgraded progressively and fine-tuned with feedback from the market. Therefore, we suggest that the ideas be parked for now, and developing a vision and a roadmap take precedence. Ideas can be part of the roadmap, to be released in later versions.

Step 2. Design and Specifications: Once there is clarity on the product concept, the next step is to flesh it out and add details. You need to understand the effort each feature will require and how it will interact with the rest of the product. You can use product design tools to generate 2D/3D models that can simulate, validate and analyze the product, and get user feedback. This stage ensures that the final product will conform to the desired specifications and requirements.

Step 3. Product Launch and Market Development: Once the design has been finalized and revised based on feedback, the developers can get into action, with a product manager monitoring the entire process to ensure quality, conformance, and timely delivery. Parallelly, you can also create marketing strategies and put them into practice to create a ripple in the market.

You need to arrive at the right pricing. It should neither be formidably high nor make the product look cheap. To be profitable, it must cover the cost of resources, effort, and marketing expenses.

Testing can also happen parallelly in the DevOps approach. Live users may also be used to test the product closer to release. The internal and external stakeholders can come together to ensure the product performs as promised, delivers value, solves the pain point for which it was created, and is compliant with applicable regulatory requirements.

Step 4. Review and Improvements: Based on the reaction of the users and the roadmap decided on earlier, new features can get added to the product. With each addition, it needs to be tested to ensure that the new features integrate seamlessly with the existing ones.

Feedback, analytics, and user data can help the development team make informed decisions on what needs strengthening, which features need improvement, and what is not working at all.

Indium Software worked with a US-based FinTech firm that specializes in cutting-edge payday lending solutions. It serves 0.5 million consumers, handling 7 million transactions plus. But the loan workflow processes were ineffective, slow, and costly. There were a lot of manual processes that made the system inefficient and resource intensive. Indium developed a responsive user interface after analyzing the current process, interacting with the users to understand their roles and requirements, assessing consumer behavior, and evaluating the regulatory requirements to improve workflow efficiency.  

A scalable and adaptable architecture was put in place automating nearly 70% of the receipt process. This resulted in improving the robustness of the origination process and responsiveness to loan applicants.

Post-Product Release Best Practices

Time-to-market plays a critical role in deciding the success of the product, along with the presence of innovative features and value additions. Another factor to keep in mind is that over time, other similar and better products may enter the market, making your product irrelevant. So, you must constantly evaluate the product and compare it with its peers, or even other products that may not be directly competing with it. This will help assess what kind of features need to be added and help understand how your product can remain relevant to its customers.

At times, it may also require the product development team to start afresh and bring a completely new product into the market. For instance, when cloud computing and cloud migration became widely prevalent, it compelled businesses to reconsider their product development strategy and focus on developing more cloud-native solutions.

Product engineering goes beyond product design and development. Compliance, governance, and security are also important aspects. The right technology stack and architecture can have a tremendous impact on product performance along with making the pricing competitive.

Indium Software has a team of cross-domain experts working closely with the technology team to design, develop, and test products. We work with businesses of all sizes, developing cost-effective, innovative, and high-performance products.

FAQs

The post Understanding the End-to-End Product Development Lifecycle appeared first on Indium.

Screen Readers

Screen readers are a type of assistive technology that enables people with visual impairments or blindness to access and interact with digital content on a computer or mobile device. A screen reader is a software application that converts digital text into synthesized speech. To test screen readers, the product should be checked to ensure that it supports screen readers such as JAWS (Job Access With Speech), NVDA (Nonvisual Desktop Access), and Voiceover. The product should also be checked to ensure that all content is accessible to users with visual impairments, including images, videos, and other multimedia content.

When testing screen readers, it’s important to check that the software works well with the screen reader, and that all content is accessible to users with visual impairments. This includes checking that all images, videos, and other multimedia content have appropriate alternative text descriptions. Additionally, it’s important to check that the screen reader can accurately read all text on the page, including text that is styled in different ways, such as headings, bold text, and italicized text.

It’s also important to test the screen reader’s ability to navigate the product. This includes testing that the screen reader can accurately identify and navigate to links, buttons, and other interactive elements on the page. Additionally, it’s important to test that the screen reader can properly identify the current page and provide users with feedback on their location within the product.

Finally, it’s important to test the screen reader’s ability to handle dynamic content, such as pop-up windows or content that is displayed after a user takes an action. This includes testing that the screen reader can accurately identify and interact with these elements and that users are provided with appropriate feedback on the changes to the page.

Magnification Tools

Magnification tools help users with visual impairments increase the size of the content on their screen, making it easier to read and interact with digital content. To test magnification tools, the product should be checked to ensure that it supports zooming features such as pinch-to-zoom and double-tap-to-zoom. The product should also be checked to ensure that all content is legible and visible at different zoom levels.

When testing magnification tools, it’s important to ensure that all content is legible and visible at different zoom levels. This includes testing that the zoom feature doesn’t cause any distortion or loss of quality in the content, such as blurriness or pixelation. Additionally, it’s important to test that the product’s layout and design remain intact at different zoom levels, and that users are still able to navigate and interact with the product effectively. It’s also important to test that the magnification tool doesn’t cause any unintended scrolling or zooming, which could be disorienting or frustrating for users. Finally, it’s important to test that the magnification tool is consistent across different devices and platforms, ensuring that all users can access and use the feature regardless of their device or operating system.

Keyboard Navigation Tools

Keyboard navigation is an essential navigation feature of any software or web application, especially for people who cannot use a mouse or have limited mobility. In addition to the basic requirements mentioned earlier, there are several best practices that should be followed to ensure that keyboard navigation is effective and user-friendly.

One such best practice is to provide keyboard shortcuts for commonly used functions. These shortcuts can be assigned to specific keys or key combinations and can significantly improve the efficiency of using the application.

Another important aspect of keyboard navigation is ensuring that the keyboard focus is always visible and easily identifiable. The keyboard focus is the element that is currently active and can receive keyboard input. It should be highlighted in some way, such as with a colored border or a different background color, to make it clear which element is currently active.

Furthermore, it is essential to ensure that the tab order of the application is logical and intuitive. The tab order is the order in which the keyboard focus moves from one element to another when the user presses the Tab key. It should follow a logical sequence that matches the visual layout of the application and not skip any important elements.

It is also worth noting that users may have different preferences when it comes to keyboard navigation. Some may prefer to use the arrow keys to navigate between elements, while others may prefer to use the Tab key. Therefore, it is important to provide options for customizing keyboard navigation settings to accommodate different user preferences.

Speech Recognition / Voice Command Tools

Instead of using a keyboard or mouse to interact with a computer or mobile device, users can use voice command tools, which are software applications. A tester can run a number of tests to mimic real-world usage scenarios in order to test the voice command feature.

Firstly, the tester can try using common voice commands that the product claims to support. These commands can include basic tasks such as opening and closing the application, navigating through menus, and selecting options. The tester can also try using more complex commands to ensure that the system can handle more intricate tasks.

Secondly, it is essential to test the speech recognition system’s ability to understand different accents and languages. The tester can record audio samples of users speaking different languages and accents and play them back to the system to check its accuracy in recognising the speech.

Finally, the tester should test the speech recognition system’s ability to work in different environments, including those with background noise. The tester can simulate noisy environments by playing sounds in the background and testing whether the speech recognition system can filter out unwanted noise and accurately recognize the user’s commands.

Braille Displays

A braille terminal, also known as a refreshable braille display, is an electro-mechanical device that displays braille characters using round-tipped pins raised through holes in a flat surface. It is typically used by people with visual impairments who can’t read text output on a regular computer monitor.

It is important to confirm that the product supports braille output and that all content is accessible to users who rely on braille before conducting tests on braille display outputs.

Some other areas to check for are:

Verify compatibility: Check that the software is compatible with the braille display being used. This includes checking that the software can communicate with the display and that the display can receive and display the braille output.

Test different scenarios: Test the software in various scenarios, such as navigating through menus, reading documents, filling out forms, and using other features. This will help ensure that the software’s braille output is consistent and accurate throughout the program.

Test formatting: Check that the braille output is correctly formatted, including proper spacing, indentation, and line breaks. This is important for ensuring that the braille output is easy to read and navigate.

Conclusion

In conclusion, by conducting thorough testing across different domains, product teams can identify and address potential barriers that users may face, making sure that the product is accessible to everyone and hence creating a more equitable and welcoming world for all.

The post Testing Assistive Technologies in a Product appeared first on Indium.

Product features refer to the various functionalities that deliver value to the customer and include capabilities, performance, components, and even the user interface (UI) design. Broadly, features can be described as tasks or actions that empower users to achieve certain objectives, solves a user challenge, and add value to the user while aligning with a theme or an effort of work.

Every function is a sum total of several steps and each step can be further broken down into sub steps. This translates to multiple features a product must have to capture all those operations and automate the function to provide value. Now, the challenge product developers face is in deciding which features to include in the product.

A product roadmap helps to create a balance between needs and speed and is arrived at after defining, analyzing, and prioritizing features. The process of arriving at the must-have features must be repeatable and standardized. Most importantly, it should be tied to a business objective to ensure that the product is not only feature-rich but also delivers value.

Feature vs Value

A product feature offers a functionality that benefits the users in some way. These benefits can vary in criticality, ranging from disrupting the way a process is done to enhancing the process efficiency or a nice-to-have feature with no serious impact. This impact on operations will also determine how effectively the feature will be used or whether it will be destined to be buried amongst the hundreds of other similar nice-to-have but not critical features. This will make the product seem less serious and lose a competitive advantage.

Since there can be many demands for different kinds of features and the limitations on cost, time, and resources prevent all the features to be delivered at the same time, prioritization becomes essential. This requires defining the feature, identifying its value to the user, estimating the time needed to develop and deploy, and plan further enhancements.

Even for businesses that focus on a single product or single function, this can be difficult. For businesses that try to provide end-to-end solutions or multiple products, this can be even more difficult. Also, different customers at different maturity levels will need different features, further complicating the decision-making process.

Measuring Value with Metrics – Best Practices

How to decide which features are critical and which are not? To evaluate the features, their usefulness should be measured in quantifiable ways as otherwise, the product may become bulky and unwieldy or not serve its intended purpose.

It may be of interest to read our Application Performance Engineering Success Story: Leveraging Elasticsearch for A Global Supply Chain Company.

Some of the Best Practices for mapping your features to measurable business outcomes include:

Make Feature Development Goal-Centric

Have a ‘goal-first’ approach to product development where the strategic initiatives are derived and a roadmap and requirements aligned with it. Communicating the direction of product development to all stakeholders will ensure greater cohesiveness and better collaboration.

Understand Customer Needs to Define Features

To be able to identify features and define them, it is important to understand the users, their pain points, and how your product can help them solve them. Creating buyer personas and mapping the features to the personas will help arrive at the feature list. User story mapping is a visualization of the customer journey that can also help to map the features to the personas.

Prioritize Features Based on Benefits

Identify the value the different features offer and establish metrics on how they can benefit the business. Based on the scores, rank them and calculate the RoI in terms of time, cost, and resources to arrive at the list of features that make it to the roadmap.

There is no single formula to calculate the value but here is a guideline to some criteria for assessing the value:

• Functional Value: It addresses a pain point
• Monetary Value: How much is it worth to the customer
• Social Value: The impact of the product on being able to connect to others
• Psychological Value: How it reinforces their identity

These benefits can be further divided into two categories: tangible and intangible. Tangible would include factors such as convenience, reliability, and cost. Intangible is more subtle and includes emotions, causes, and status. Together they will determine the USP of the product, increasing its desirability for the customers.

Data and analytics are critical for the feature development process to provide insights into user requirements and immediate needs, and help to arrive at the value of each feature. Therefore, having access to meaningful and relevant data is critical to the product engineering process.

Indium – For Measurable Business Outcomes

Indium Software is a cutting-edge technology solution provider with vast experience in product engineering and data engineering. Our team of technical experts with cross-domain experience work closely with product development companies as their extended arm, providing bespoke solutions best suited to their product and business objectives.

We provide end-to-end solutions to develop goal-first, feature-rich products that enhance the digital experience and break barriers of innovation. Our understanding of business domains enables us to contribute significantly in identifying and defining critical features, establishing the metrics to rank them based on value, and prioritize the development process for timely delivery in a resource-efficient manner.

FAQs

The post Product Engineering 101: Map Your Product Features and Capabilities with Measurable Business Outcomes appeared first on Indium.

For financial and banking sectors the stakes are always different and will be high. At the same time the success involves aiming for diverse and ever-changing goals. However, banks must now use contemporary technology and processes in order to be a part of a bigger economic ecosystem. They can no longer isolate their activities or rely on antiquated systems. But how many banks have chosen this route, and are they comfortable depending on cutting-edge techniques and new technology?

To innovate, banks must work together, and technology is the key to success. In order to better serve their customers, who are becoming increasingly acclimated to mobile banking, banks should choose the proper development strategies.

Check out this informative blog post: Challenges With Data Migration And Cloud Data Migration In The Financial Sector.

Let’s discover more about loan origination software, which is a crucial tool for FIs to build up their digitization game in order to enhance both their clients’ experience and their lending procedures.

What is a Loan origination system (LOS)?

By definition, it is software or set of tools used by financial institutions to process and manage loan applications, it is is used to automate and streamline the loan origination process. Banks, mortgage lenders, and other financial institutions utilise LOSs to quickly process loan applications, evaluate creditworthiness, and decide whether to give money.

Online application and submission, credit evaluation, document management, collaboration, and communication are a few of the main characteristics of LOS. LOS frequently allows borrowers to apply for loans online and submit all necessary papers electronically. This might hasten the processing of loan applications, evaluate the borrower’s creditworthiness more quickly, and grant approval before granting the loan.

Managing and preserving loan paperwork, such as loan applications, credit reports, and other supporting papers, can also be facilitated by a loan origination system. LOSs enable collaboration and communication among all parties engaged in the loan origination process, including lenders, borrowers, and other stakeholders, in a single central location.

The reason why banks need to establish a loan origination system

Many manual operations associated with loan processing, such as checking application information, figuring out loan conditions, and preparing documentation, can be automated by a LOS. This can enable banks to handle more loans in less time by saving them time and resources. An LOS can assist banks in making sure that loan applications are handled accurately and consistently. This can lessen the possibility of errors or blunders that could result in monetary losses or harm the bank’s reputation.

Fair Credit Reporting Act (FCRA) and Equal Credit Opportunity Act compliance: An LOS can assist banks in making sure they are in compliance with pertinent laws and regulations (ECOA). A well-designed LOS can give clients a smoother and more effective loan application procedure, enhancing their entire experience.

Overall, a loan origination system can offer banks and FIs a variety of advantages, such as increased productivity, higher accuracy, better client satisfaction, improved risk management, and regulatory compliance

What problems do historical loan origination systems have?

Legacy loan origination systems are computer systems that were created and put into use in the past but are still in use today. Financial institutions and other organisations that use these systems may face a variety of difficulties and problems. Legacy loan origination systems frequently have problems with the following things:

It can be challenging to maintain and improve legacy systems since they are frequently created utilising antiquated technologies and inefficient construction techniques. This may result in security flaws, subpar operation, and incompatibility with contemporary systems. Legacy systems frequently have rigid, labour- and error-intensive manual processes. Due to this, it may be challenging to efficiently originate and process loans, which may cause delays and annoyance for clients.

The ability of a company to deliver new products and services may be restricted by legacy systems’ potential limitations, which are more like functionality that may never be fully realised. Due to the potential need for specialist knowledge and resources, maintaining and upgrading outdated systems may be more expensive and choosing certified developers is a biggest task. Furthermore, older systems may struggle to communicate with other systems, which can limit an organization’s ability to share data and improve operations.

Overall, legacy loan origination systems can be a hindrance to the efficiency and effectiveness of an organization’s loan origination process. As such, many organizations are looking to modernize and upgrade their systems to overcome these challenges.

What role does new technology play in helping banks create cutting-edge loan origination systems?

By using automation, banks can streamline the loan origination process and reduce the time it takes to review and approve loans. Automation can be used to handle tasks such as verifying customer information, calculating loan terms, and generating documents. Another excellent alternative that banks may use is digital documentation, which helps to reduce the requirement for paper-based documentation and improves the efficiency of the loan origination process. It is simpler for banks to obtain and review loan applications because digital documentation can be stored and accessible electronically.

Integration with other systems: To give clients a more seamless and complete service, modern LOSs can be integrated with other systems and technologies, including as customer relationship management (CRM) systems and digital wallets.

A bank’s loan origination system can be upgraded using a variety of development tools. To enhance their loan origination systems in accordance with their needs, companies frequently use programming languages, databases, integrated development environments (IDEs), source control systems, test automation tools, and many more. The main effort left for FIs after choosing the appropriate tools, apps, and solution is to find the best consultants, certified developers, or application developers who may be the biggest assets as you go through the process of improving your solution.

A specific success story

The client is a well-known US community bank that has been helping Californians and small companies for almost a century. The FinTech firm specialises on cutting-edge payday lending solutions. Through their online platform, which handles more than 7 million transactions for 0.5 million consumers, loans are originated.

Business Requirements

• The client’s old workflow processes were ineffective, time-consuming, and expensive given the large volume of transactions.
• Work receipts were manually submitted and processed for further decision-making, which resulted in a system that was extremely inefficient and that allocated too many resources to repetitive and automatable operations.
• The bank needed to update their loan origination system in order to do away with the current manual procedure and streamline everything to almost complete automation.

Due Diligence / Planning Preparation

• Given the sheer number of transactions, the client’s existing workflow processes were inefficient, time consuming and expensive, so there is a need to enhance the existing legacy loan origination system to digital loan origination software and implemented Digital-ready application.
• With more than a decade of experience in the fields of application engineering and data analytics, our certified developers has closely worked with the client to have a better understanding and fix the pitfalls.
• Identified and prioritized that there is a need of a responsive user interface that eliminates the existing manual procedure and streamlined almost the whole business process to near automation.

Solution

• A proper business workflow, including decision processes for the loan approval process, is established with the aid of the Indium’s application modernization services, according to understanding.
• Implemented Decision system interaction touch points using APIs
• Data flow analysis from APIs, client attributes and third-party data to a converged central data repository.
• Automated the work receipt upload mechanism by creating a comprehensive user interface that captures data fields to contribute to decision inputs.
• Without affecting the current functioning, the system was upgraded using scalable architecture (Java, AngularJS, and Spring Boot).
• Functional and performance testing was done at the micro service level.

Business Impact

• 70% less manual work was required in the receipt process, directly enhancing the robustness of the origination process and the responsiveness to loan applicants.
• The architecture that has been put in place is very scalable and adaptable to different data sources. The data repository serves as an effective source of information for workflows and optimization techniques.

Technology

Based on our client’s specifications, we built the LOS using AngularJS, HTML 5, CSS 3, Bootstrap, Spring Boot, MySQL, Google Material Design, JIRA, and GIT Hub. This is not the end; we have multiple technologies and are not limited to just one; we can implement or build any environment based on your pitfalls and business requirements, using various technologies and tools.

Conclusion

Due to the increased focus on omni-channel banking experiences, the BFSI business is growing rather swiftly. Growing technological use and the acceptance of mobile banking have changed the norms governing the industry. Instantaneous, flawless enjoyment is currently the industry’s driving force. Strong, high-performance apps with top-tier application developers are now necessary if you want to be adaptable and sustain market leadership.

Interested to learn more? Contact us today.

The post How can technology assist banks in optimizing their loan origination systems and accelerating growth? appeared first on Indium.

In India, farmers rely mostly on traditional methods and techniques to grow crops. These traditional methods come with their own pros and cons.

Agrotechnology applies AI to assess the type of crops to be grown in specific soil, amount of fertilizers to be used, climate change issues, etc., and increase amount of crop harvest. Agrotechnology has the potential to use resources wisely, make crop production more consistent and efficient. Digital tools can be used at all stages of farming and also in the post-harvest process.

Efforts have been carried out globally to strengthen the agriculture and food production sector by digitizing the overall process of food production.

The Confederation of Indian Industry has suggested several strategies to adopt digital tools for farming and food production,

• Build a digital infrastructure and use satellite imaging and data sources
• Elevate data efficiency by using digitization tools

Technologies For Digitization

In the agricultural sector, many technologies are adopted to digitize the whole process.
Precision agriculture is one such technology that has great potential in changing the way of traditional farming practices. Some of the outcomes of using precision agriculture are,

• Automatic section control
• Yield monitoring
• Chlorophyll sensors
• Soil sampling
• Aerial imagery
• GPS guidance systems

AI sowing application is another initiative that is powered by the Microsoft Cortana
intelligence suite. This app is of great use to farmers, which doesn’t require any investment or installation of sensors. Advisors on sowing seeds are sent as a text message to the registered mobile.

With a further step forward, Microsoft has now developed a Pest Risk Prediction API in
collaboration with United Phosphorus Limited. This uses artificial intelligence to indicate the risk of pest control in advance. This will be of great help in increasing yield and lowering the economic losses caused due to the infestation of pests.

Cloud computing is another technology that helps with real time computation, data access and storage. The pros of using cloud computing for the digitization process include crop related decision making influenced by soil information, monitoring the growth and crops and comparing growth patterns, data of farming practices of local farmers can be studied, etc.

The next technology is the Internet of things (IoT), which translates to a simple definition as the Internet controlling things. Innovation includes agrobots, but these are still under the trial phase or R&D mode. AI aided machines include weeding robots, harvesting robots, material handling, machine navigation.

Technology Related Testing:

Since there are many technologies that are adopted in agriculture, there are a lot of testing processes that are needed to be done before digitalizing the whole process. Among the man testing techniques that are being used in digitalizing agriculture, the one testing technique that plays a major part is the RPA (i.e., Robotic Process Automation) since AI plays importance in many places such as AI sowing application, Automatic section control, weeding robots, harvesting robots, etc

Robotic Process Automation has many different tools which can be used for various types of testing. Each and every tool in RPA has its own and different advantages and disadvantages. Here are few tools and their uses.

Also, since drones are used in many places to prevent crop yield loss from factors such as
diseases, insects, weeds and nutrient deficiencies, Lithographic lens testing is one of the best testing techniques which can be used to test the measured aerial images, interferometric data, and photoresist measurements.

Since we have been using technologies like drones, lithographic lens, etc., there are different types of hardware testing too that can be performed over them. A few hardware testing that can be done to check the chassis, motors, Propellers, indicator lights, Global Positioning System, Landing frame, batteries, Electronic Speed Controller, Compass, wiring and Camera.

Conclusion

Finally, these technologies are still under the trial phase so, we have to wait to experience their uses. But once these are implemented successfully, they will be more helpful and useful in the field of agriculture and also it reduces the loss in terms of preventing diseases, weeds and nutrient deficiencies, etc.

Again, every technology has its own advantages and disadvantages so, we can see them in these technologies too.

The post Applications of AI in Agrotechnology appeared first on Indium.

Angular is a platform and framework part of full-stack development used to build client-side applications, to provide good performance and more sensitive applications for large applications.

Most of the Angular developers are experiencing that large applications are taking more time for the initial load of the application, so this will result in a bad experience to the user.

The main goal of this post is to decrease the initial loading time and speeding up the page navigations.

How to increase and achieve the initial load performance in Angular:

To increase the initial load performance, we have to organize the code structure, optimize the main-bundle file size, split the single modules into a lot of smaller modules and apply the wonderful concepts of Lazy Loading in Angular for each and every smaller module.

We also need to import your modules using only Absolute path.

List of problems to be resolved:

1. Main bundle size will be high, and it needs to be optimized.

2. Imported a lot of components in a single module.

3. For large applications, we should definitely use the concepts of Lazy Loading.

4. While taking a build in production profile, the application will throw an unknown error message.

Organizing the code structure:

To build a large application in Angular, we need to focus on folder and code structure to define a well-organized structure for your project.

Impact when the application grows in size:

• Most of the developers will be facing an issue while developing the application – especially when the application grows in size.

• They continuously add new implementations and features with no real structure in a place.

• This will make it very hard to locate the services, modules and make additional changes to the code and folder structure and it will become time-consuming.

• Also, while working in large applications, we should not create a large number of components unnecessarily because it will lead to grow your application size and give a bad performance.

• To overcome this issue, we can create one generic module to minimize your code and project size.

Modules:

• Modules in Angular are simply a class as it contains components, services, pipes and directives and the other code files whose scope is defined by the NgModule.

• It is generally organized in modules like packages or bundles containing the required code for a specific use case.

• Every Angular application has at least one NgModule class, the root module named as AppModule.

• While developing a smaller application, you have only limited number of screens in that application so you can use one root module named as AppModule.

• When you go to larger applications it has a lot of implementations and features, in that case, you need to separate your modules into smaller features of modules and import those smaller modules into your App Module.

|– modules
           |– home
               |– components
               |– pages
               |          |– home
               |                   |– home.component.ts

            |                   |– home.component.html

            |                   |– home.component.scss

            |                   |– home.component.spec
               |– home-routing.module.ts
               |– home.module.ts

Problem 1: Main bundle size will be high, and it should be optimized:

Impact on creating a number of components in large applications:

As you can see over time in main.js file which will be bigger in size, it’s a problem in order to see the first page of your application, at that time it downloads the main.js file from the server and stores it in chunk.js file and renders the first page on the specific page.

This will affect our applications as it will take more time to load the initial page of your application and it will give bad performance to our clients.

Optimize the Bundle.js file:

• When we build our application, primarily a module bundler can transform all your assets like HTML, CSS, images into javascript files.

• It will create number of files like polyfills.js, scripts.js, runtime.js, styles.css, main.js. If main.js file takes a longer time to download from the server, it means initial load of the application will take more time to show the application’s first page, only after some time the user can see the first page of your application.

   1. polyfills.js – Compatible for different browsers.

               2. scripts.js – Scripts section of angular.json.

               3. runtime.js – Webpack loader to load other files.

               4. styles.css – Styles section of angular.json file.

               5. main.js – It contains all our code including components (.ts,.html and css codes), pipes, directives, services, and all other imported modules.

To overcome and achieve the initial speed of your application:

• Creating a single module into several smaller feature modules for your larger applications.

• To decrease the initial loading time and to provide good performance to your larger application, there is an awesome concept in Angular named as Lazy Loading.

• Apply, Lazy Loading concept for each and every smaller feature module in your application.

• Import your modules only using Absolute path in each and every component in your application.  

Problem 2: Imported a lot of components in a single module and it should be modularized by creating smaller feature modules for every component:

Impacts on not creating a separate module for every component in large applications:

For smaller applications we don’t want to create a separate module for every component, we can simply import those components in the parent module.

For larger applications, there would be lot of concepts and components that will increase in size as well so it will affect the application’s performance badly.

For Example:

• For larger applications, we have lot of folders. Inside the folders, there should be a huge number of sub-folders.

• In each and every sub-folder there must be a lot of components for this sub-folder, we also have one sub-folder module.

• Import all your sub-folder modules in your parent folder module. Finally, you can import all your parent folder modules in your App-module.

1. Folder – Accounts.

2. Sub-folders – Activate, Password and Settings.

3. Components in every Sub-folders.

4. Parent folder module – Accounts Module.

While your application grows in size and the number of folders also increases, it means you will be facing a performance issue at the time of initial load of your application or in any manner.

To avoid this bad performance, we need to create smaller feature modules for every component and import those smaller feature modules into your parent sub-folder module.

1. Create a smaller feature module for every component.

             2. In Activate sub-folder, create a separate module file for Activate page, Activate Detail    Page, Activate Edit component. Similarly, create modules for all the Password and Settings sub-folder components.

             3. Now import all your created separate feature modules in the particular folder modules. For example, import your Activate Page module, Activate Detail Page module, Activate Edit module into your particular folder module in Activate Module.

             4. Similarly, do the same procedure for all the sub-folders in your application.

             5. Finally, import your particular sub-folder modules into your parent folder modules (Account Modules).

Problem 3:For large applications, we should definitely use the concepts of Lazy Loading:

Code Optimization in Angular:

In Angular applications, initially, app loads and all the files like HTML, CSS, images and all the modules get downloaded from the server, it gives mainbundle.js file.

Impact on number of NgModules loading unnecessarily at the initial load of the application:

To overcome this poor performance, we need to use the concepts of Lazy Loading and Route-level Code Optimization.

1. Lazy Loading:

• Lazy Loading is one of the concepts in Angular Framework to provide good performances for larger applications.

• After using Lazy Loading for those particular modules, at the time of initial load of that application, the Lazy-Loaded modules will not get downloaded from the server.

• When the particular route is activated, only then will the Lazy-Loaded module get downloaded from the server.

• So, it will reduce the downloading time at the initial load of that application and also provide good performance for the entire application.

2. Route Level Code Optimization:

• In large applications, there would be a lot of routes and modules as the application grows in size and leads to bad performance.

• For example, if we have a Home page, Orders page we need to use the concepts of Lazy-Loading in the App-routing module.

        const routes: Routes = [

              {

                    path: ‘home’,

                    loadChildren: () => import(‘./home/home.module’).then(mod => mod.HomeModule)            

               },

               {

                    path: ‘orders’,

                    loadChildren: () => import(‘./orders/orders.module’).then(mod => mod.OrdersModule)

                }

          ]

• Also, we don’t want to import these modules in the particular parent module. Only this module gets downloaded when the particular route customers and orders page is activated.

Apply Lazy-Loading for every smaller feature module:

• For larger applications, we need to use the concepts of Lazy-Loading in each and every smaller feature module in the App-routing module.
• This is done so that you get better performance at the initial load of that application and also for the entire application.

Problem 4: While taking a build in production profile, the application will throw an unknown error message:

Impact while building your production profile, it throws an unknown error message:

While building your application, if you have added the forward slash at the end of the folder, it means Typescript will not show the exact error.

To avoid the unknown errors, only use the absolute path while importing your files in your component.

Importing the modules using Absolute path:

• While importing your files or modules in your component, use the absolute path, starting from the top of the folder configuration.

• Also, avoid adding the forward slash at the end of the folder while importing your files in a particular component.

 Conclusion:

  In Summary, to achieve and increase the initial load performance in Angular the following can be done

• Use code optimization,
• Organizing the code structure,
• Optimizing the bundle.js file and
• Using the concepts of Lazy Loading in Angular.

The post Code Optimization in Angular to Enhance Performance of Websites appeared first on Indium.

Mendix is a high productivity app platform that enables you to build and continuously improve mobile and web applications at scale.

The Mendix Platform is designed to accelerate enterprise app delivery across your entire application development lifecycle, from ideation to deployment and operations. It is based on visual, model-driven software development.

What is Mendix Platform SDK?

The Mendix Platform SDK is a TypeScript- & JavaScript-based SDK that, through the Model SDK, provides access to the inner workings of every Mendix app through an API that enables you to automate any tedious or error-prone task.

Use Cases of Mendix Platform SDK:

• The Mendix SDK allows you to create legacy software transformation tools that helps developer to convert legacy applications to cloud-based Mendix application.
• Bootstrap new apps, modify existing app and generating documentation.
• To calculate industry standard software metrics like cyclomatic complexity and fan-in/out of micro-flows.
• Exposing your micro-flows as Web Service/App Service and your entities as Data resources
• Reorganizing the layout of your app model in the blink of an eye
• It is mainly used in the situation when your monolithic application is converted into micro-service applications and the developer has to maintain the same theme and same user roles

Setting up the working environment:

1. Install Node.js in your machine
2. Create the directory where you are going run your script
3. Inside the directory use the comment “npm init –yes” , it will create package.json file with default dependencies.
4. Use “npm install -g typescript” , it will install typescript
5. Add the mendix platform dependencies through “npm install mendixmodelsdk mendixplatformsdk when @types/when –save”
6. Initialize typescript by using “tsc –init”, It will create tsconfig.json file with compiler specification.

Working with Mendix Model SDK:

Mendix platform SDK starts with the creation working copy, developer creates the working copy of the existing project by using the project id, project name and the username, API key of our mendix account.

The Platform SDK allows you to take a specific project, branch and revision, and make it available as an Online Working Copy – essentially the equivalent of a local Team Server working copy, but in the cloud.

You can then access the app model to analyze it, make changes, and generate new elements. And finally, once you have applied all the changes you want to make, you can commit those changes back to the Team Server.

• A working copy is a local copy of the project. You can easily identify the modules, domain model, entities, attributes, module roles, access rules etc.., inside the working copy.

Sample script to create working copy

Once the working copy is created, we need to do the following steps to find the model view of the project. The steps includes as follows,

• Exploring a model
• Loading all elements of the model
• Changing the model
• Committing the changes

Structure Of Working Copy

Project settings and security:

This settings influence the behavior of the runtime when running the mendix application.

We can define the static values of constants based on the configuration. we can add the startup microflow inside the project settings to run some of the basic scripts you need to run when the application gets loaded (for example: loading the DTAP information).

We can define time zone of the scheduled events, application language, certificates to connect the web services.

The security of the project includes the security levels(off, prototype/demo, production), list of user roles with the mapping of module roles, application admin username and password, list of demo users and password policy.

Navigation document:

It defines the navigation structure of the application for users. It also allows you to set the home page of your application and to define the menu structures.

we can also add the navigation profiles here based on the device types (Desktop, Phone, Tablet).

Modules:

Modules are a way to split the functionality of your application into separate parts. Within a module you can define module security via module roles and specify security settings of those module roles for pages, micro-flows, entities and datasets.

Domain Model:

A module always contains exactly one domain model. The domain model is a data model that describes the information in your application domain in an abstract way.

Which consist of number of entities and the association between entities.

Pages:

Pages define the end-user interface of a Mendix application. Apart from pages, there are two other types of documents that come into play when creating an interface: layouts and snippets.

Pages are the things that are actually shown to the end user. Snippets and layouts are building blocks for creating pages, but they are not shown to the user directly.

The pages are basically designed with the collection of widgets such as, data views, data grids, list views, action buttons, drop down buttons and the number of custom widgets created by the mendix users.

We can use these things along with the default and custom styles.

Micro-flow:

Allow developer to express the logic of your application. A microflow can perform actions such as creating and updating objects, showing pages and making choices.

It is a visual way of expressing what traditionally ends up in textual program code. It also includes the error handling functionality

Other Resources:

Apart from the pages and micro-flows the modules also includes the resources such as, constants, document templates, java actions, published web services, regular expressions, scheduled events, message definition, XML schemas, JSON structures, etc.,

Exploring a Model

The root object refers to the root project node in the Project Explorer in the Mendix Modeler, and from here on you can walk through the project tree and into specific documents.

Loading all the elements

Each element (whether in interface or full form) has an isloaded property and load and asloaded functions. Isloaed property indicates whether this element is fully loaded already.

In practice you should never need to test its value, but simply make sure that you always load a unit/element first.

By using the following script we can load all the modules of our application

const workingCopy = await client.model().openWorkingCopy(workingCopyId);
const modules = workingCopy.allModules();

Changing the model

All units and elements can be freely altered after loading as long as you adhere to the type system.

To create new units, you need to pass the parent structural unit to the constructor.

const newEntity = domainmodels.Entity.createIn(domainModel);
newEntity.name = entityName;
domainModel.entities.push(newEntity);

Committing the changes

After completing all the changes we need to commit the working copy by using the following comment, await workingCopy.commit();

To wait until all changes are submitted to the server, use the close connection function of the model object.

Example: workingCopy.model().closeConnection();

Conclusion

• The Mendix Model SDK provides you with a whole new way of interacting with your app. Through this API, you get full access to all the aspects of your app model, enabling you to both read from and write to it.
• We can extract the model from the application and also reuse the model to other applications too.
• By using this model SDK the theming process between applications also gets more efficient.

The post TypeScripting in Mendix appeared first on Indium.