Cloud engineering is rapidly transforming the way we build and deliver applications. As more businesses embrace cloud computing, the demand for skilled cloud engineers is skyrocketing. According to recent research by the Synergy Research Group, the cloud infrastructure services market grew by 35% in 2021, reaching a record-breaking $130 billion in revenue. This growth is a clear indication that cloud engineering is no longer just a trend, but a fundamental shift in the way we approach application development and delivery.

In Q4-2022, Microsoft has seen a significant increase in its global market share among the major cloud providers. Its current market share stands at 23%, which is higher than the average of 21% in the previous four quarters. Amazon, the market leader, has maintained its market share range of 32-34%, while Google's market share has remained steady at 11% compared to the previous quarter, but has increased by one percentage point from the same period last year. Collectively, these three companies now account for 66% of the global market, up from 63% a year ago.

In this article, we'll delve into the benefits of cloud engineering and how it's changing how we build and deliver applications. We'll discuss how cloud engineering makes it easier to scale and optimize applications, streamline development workflows, and improve overall performance, reliability, and ROI. So let's get started!

Building and Delivering Applications on the Cloud: Addressing the Pain Points

Traditional application development and delivery methods can be slow, costly, and inflexible. Some of the pain points of traditional methods are-

• Slow time-to-market: Traditional application development and delivery methods can be slow and time-consuming, leading to delays in getting products or services to market.
• Limited scalability: Scaling traditional applications to meet changing business needs can be difficult and costly, often requiring significant infrastructure investments and long lead times.
• High costs: Traditional application development and delivery methods can be expensive, with costs associated with hardware, software licenses, and ongoing maintenance.
• Security risks: Traditional methods may not have robust security measures in place, leaving applications vulnerable to cyber-attacks and data breaches.
• Lack of flexibility: Traditional methods can be inflexible, making it challenging to respond quickly to changing business needs and customer demands.

That's where cloud engineering comes in. By leveraging cloud computing technologies, businesses can build and deliver applications faster, with greater scalability, security, and reliability.

Why Move from the Status Quo and Adopt cloud engineering?

Industry data and experts explain the many benefits that come with cloud engineering-

According to a report by Gartner, "Cloud computing will become the default option for software deployment by 2025." The report notes that cloud-based application development and delivery methods can improve agility, reduce costs, and increase scalability.

A Forbes article highlights that businesses that adopt cloud engineering practices can benefit from "faster innovation, more efficient resource allocation, and higher customer satisfaction." Cloud engineering can enable businesses to be more responsive to changing market conditions and customer demands.

The Wall Street Journal reports that companies that adopt cloud engineering practices can achieve "greater speed, flexibility, and agility in their application development and delivery processes." Hence, cloud engineering can also enable businesses to reduce costs and improve security.

Overall, these statements from industry experts suggest that businesses that adopt cloud engineering practices can benefit from improved agility, scalability, cost savings, security, and customer satisfaction, among other things.

Embracing Cloud Engineering: 4-Steps to Change the Way to Build & Deliver Apps

Step 1: Embrace cloud-native architectures

Cloud-native architectures are designed to take full advantage of cloud computing technologies, enabling businesses to build and deploy applications faster and more efficiently. These architectures typically rely on containerization, microservices, and serverless computing, which can help to improve scalability, reliability, and flexibility. Companies like Amazon and Google have been early adopters of cloud-native architectures, using them to build and deliver their own services and platforms.

Step 2: Leverage cloud-based development tools and platforms

Cloud-based development tools and platforms can help to streamline the application development process, allowing teams to collaborate more effectively and speed up time-to-market. For example, Amazon Web Services (AWS) offers a range of development tools and platforms, including AWS CloudFormation, AWS Elastic Beanstalk, and AWS Lambda, which can help businesses to build and deploy applications in a more agile and scalable way.

Step 3: Emphasize DevOps and Automation

DevOps and automation are key components of cloud engineering, enabling businesses to automate routine tasks and accelerate the development and deployment of applications. By adopting DevOps practices, teams can work together more effectively, sharing knowledge and resources to build better applications faster. Amazon is known for its DevOps culture, which emphasizes automation, continuous integration, and continuous delivery to speed up the development and deployment process.

Step 4: Prioritize security and compliance

Security and compliance are critical considerations when building and delivering applications in the cloud. Businesses need to ensure that their applications are secure, compliant with industry regulations, and can withstand cyber-attacks and data breaches. Amazon has invested heavily in security and compliance measures for its cloud services, offering a range of tools and services to help businesses protect their applications and data.

Companies like Amazon have set the standard for these practices, demonstrating how cloud engineering can help businesses to stay competitive and innovate in today's fast-paced digital landscape. Werner Vogels, the CTO of Amazon, has spoken extensively about the benefits of cloud-native architectures and the importance of DevOps and automation. He has emphasized the need for businesses to be agile and flexible in order to adapt to changing customer needs and market conditions and has argued that cloud engineering is key to achieving this.

Leveraging Cloud Engineering for Better ROI (Return on Investment)

There are significant ROI benefits to adopting cloud engineering practices. By reducing costs and improving efficiency, businesses can achieve a positive ROI and see a significant return on their investment in the cloud. For example-

A study by Nucleus Research conducted in 2018 found that cloud applications deliver 1.7 times more ROI than on-premise applications. The study also found that cloud applications deliver 55% lower TCO (total cost of ownership) than on-premise applications.

Forrester Consulting Report on Cloud Engineering Practices, 2019 found that businesses that adopt cloud engineering practices can achieve an ROI of 208% over three years. The report also found that businesses that adopt cloud engineering practices can reduce application development costs by 20-30%.

A survey by LogicMonitor conducted in 2019 found that businesses that adopt cloud engineering practices can reduce infrastructure costs by 25-50%.

Recap

Cloud engineering is changing the way we build and deliver applications. By adopting cloud engineering practices such as DevOps, automation, and cloud-native architectures, businesses can build and deliver applications faster and more efficiently, while also improving scalability, reliability, and security.

Research has shown that there are significant ROI benefits to adopting cloud engineering practices, including lower TCO, reduced infrastructure costs, and improved application development efficiency. As the demand for digital services continues to grow, businesses that embrace cloud engineering are likely to be better positioned to meet customer needs and succeed in the marketplace.

If you are looking to transform your application development and delivery process to take advantage of the benefits of the cloud, contact Valuebound, a leading provider of cloud-native software engineering services and an AWS consulting partner.

Our experienced team can help you adopt cloud engineering practices and build scalable, reliable, and secure applications in the cloud, so you can stay ahead of the competition and meet the needs of your customers. Contact us today to learn more.

Caching is the process of storing frequently accessed data or resources in a temporary storage location to reduce the time and resources needed to retrieve them. In the context of web applications, caching can significantly improve performance and reduce the server load by serving cached data instead of generating a new one each time a user requests it.

The benefits of caching in web applications include-

• Faster response times
• Reduced server load
• Improved scalability
• Better user experience

Caching can also help reduce bandwidth consumption by minimizing the amount of data that needs to be transferred over the network. Therefore, it is considered as an essential technique for optimizing web application performance and delivering a better user experience.

Overview of Redis

Redis is an open-source, in-memory data structure store that can be used as a database, cache, and message broker. It was created by Salvatore Sanfilippo and is known for its high performance, scalability, and flexibility.

Redis can be used as a memory cache by storing frequently accessed data in memory, allowing for faster retrieval times. In addition to its caching capabilities, Redis also supports a wide range of data structures, including strings, hashes, lists, sets, and sorted sets. This makes it a versatile tool for handling various types of data and use cases.

In this blog, we will explore the basics of caching with Redis and how to implement it in a NodeJS application. We will also discuss some best practices. By the end of this blog, you will have a solid understanding of how to use Redis for caching in your NodeJS applications.

Step 1: Installation and Setup of Redis in NodeJS application

Here's how to install and set them up in your NodeJS application:

1. Install Redis in the application:

npm install redis

To use Redis, users have to install it first depending on their operating system. See the guide below that best fits your needs:

Install Redis from Source   
Install Redis on Linux   
Install Redis on macOS   
Install Redis on Windows   
Install and Use Redis on Docker

2. Create a Redis client and connect to the Redis server: 
   

Step 2: Implementation of caching in NodeJS using Redis

To implement caching in your Node.js application using Redis, you can use the following approach:

• Check if the data is available in the cache.
• If the data is available, retrieve it from the cache and return it.
• If the data is not available in the cache, retrieve it from the database, store it in the cache, and return it.

Here's an example implementation of caching in Node.js using Redis: 

Best practices for caching in NodeJS

Caching is an important optimization technique that can greatly improve the performance of your NodeJS application. Here are some best practices for caching in NodeJS:

• Use a caching library: Instead of implementing your own caching mechanism, consider using a caching library like Redis. These libraries are designed for caching and provide a lot of features and optimizations out of the box.
• Determine the right cache expiration time: The expiration time of cached data should be carefully chosen. If the data is too short-lived, you'll be constantly regenerating it, and if it's too long-lived, you risk serving stale data. Consider the frequency of data updates and the importance of freshness to determine the optimal expiration time.
• Implement cache invalidation: When the data changes, you need to invalidate the cache to ensure that the next request retrieves the updated data.
• Use a consistent key format: Use a consistent format for cache keys to make it easy to read and manage. Consider including information like the resource being requested, any parameters, and the version of the cache entry.

Conclusion

Redis is a popular caching solution for NodeJS applications that can significantly improve application performance by reducing database queries and enhancing the overall speed of operations.

Redis has effective caching techniques for improving the performance of NodeJS applications. For applications with high traffic, large-scale applications, or complex caching requirements, Redis may be the better choice, but it should be implemented with care and attention to detail to ensure that it is properly configured and maintained.

If you want to learn more about how to implement Redis caching in your NodeJS project, or if you need help with any other aspect of NodeJS development, contact Valuebound. Our team of expert developers can provide you with the support you need to build high-performance, scalable web applications. Contact us today to learn more!

Valuebound is proud to present an insightful blog post authored by Neeraj, CEO, and Founder of Valuebound. The blog delves into how to make your website accessible with the help of open-source modules.

In today's digital landscape, ensuring that all users can access your website, irrespective of their abilities is crucial. Neeraj highlights seven open-source modules that can help make your website compliant with accessibility guidelines such as the Web Content Accessibility Guidelines (WCAG) 2.0.

Achieving website accessibility and ADA compliance can seem like a daunting task, but Drupal offers various tools and modules that can make it a lot easier. The seven modules highlighted in this blog post are just a few of the many ways Drupal can help you create a more inclusive and user-friendly website. By incorporating these modules into your site, you can take a significant step towards compliance and ensure that all users can access your website.

These modules cover various accessibility features, including keyboard navigation, color contrast, and image alt text. Incorporating these modules into your Drupal site can create a more inclusive and user-friendly experience for all visitors.

Check out Neeraj's blog post to learn more about these valuable tools and how they can benefit your website's accessibility.

7 Drupal Modules to Make Accessible Websites

The following infographic highlights 7 essential Drupal modules to enhance website accessibility:

• Accessibility Checker: Quickly identify and resolve common accessibility issues on your website with this handy scanning tool.
• Color Contrast Analyzer: Ensure that your website is readable for all users, including those with visual impairments, by analyzing and adjusting color contrast.
• Block ARIA Landmark Roles: Improve accessibility and organization on your website by assigning ARIA landmark roles and labels to blocks in your site's layout.
• Civic Accessibility Toolbar: Enhance your website's accessibility by providing users with customizable accessibility tools such as font size adjustment and text-to-speech capabilities.
• htmLawed: Protect your website from XSS attacks and other malicious code injections with this powerful HTML filtering tool.
• Text Resize: Give users the ability to customize their reading experience by providing a simple text size adjustment or zoom function on your website.
• Automatic Alternative Text: Ensure that all users, including those with visual impairments, can understand the content of your images with this AI-powered alternative text generator.

Conclusion

Incorporating these seven Drupal modules into your website is important to achieving website accessibility and ADA compliance. At Valuebound, we are passionate about helping organizations create inclusive and user-friendly websites. If you need assistance with your website's compliance or accessibility efforts, our team of Drupal experts is here to help. Contact us today to learn more about how we can help you create a more accessible website that's compliant with industry standards and guidelines.

Drupal theming is an essential part of creating a successful website. It helps to create a unique and appealing visual identity for your website and improves the user experience. Bootstrap, on the other hand, is a popular front-end framework that offers a set of tools and components to create responsive and mobile-friendly designs quickly and easily. By combining Drupal theming and Bootstrap, you can create a powerful and effective website that is visually stunning, responsive, and user-friendly.

In this tutorial series, we'll be focusing on Drupal 8/9/10, the latest version of Drupal, and show you how to create a custom Bootstrap based theme from scratch. We'll start by introducing you to the basics of Drupal theming, including how to create a sub-theme, add CSS and JS files, and configure settings. Then, we'll move on to Bootstrap and explain how to incorporate it into your theme, use its classes and components, and customize its styles.

Create custom Bootstrap based theme: Step-Wise Tutorial

The following setup will be done on a fresh Drupal 8.x/ 9.x/10.x site.

Step 1- Install Bootstrap Barrio theme

While the popular Bootstrap theme on Drupal.org is a great option, it's important to note that it is based on an older version of Bootstrap (version 3.x). Since Bootstrap is constantly evolving and introducing new features, it's recommended to use a theme that is based on the latest version of Bootstrap to take advantage of its full capabilities.

That's why we've chosen to use the Bootstrap Barrio theme for this tutorial, as it is built on the latest version of Bootstrap (version 5.x). This theme is designed specifically for Drupal and offers a range of features and customization options.

To add the Bootstrap Barrio theme to your Drupal site, we'll walk you through the necessary steps in this tutorial. With this theme, you can easily create a modern, responsive, and visually appealing website that will provide a great user experience.

• Open the terminal application on your system.
• Navigate to the main folder of your Drupal installation (where the file composer.json is located).
• Type the command "composer require drupal/bootstrap_barrio" to install the Bootstrap Barrio theme and its dependencies.

Using Composer to install the theme is a straightforward process, and once installed, you'll have access to a range of features and customization options to create a modern and visually appealing website.

Step 2- Create a Subtheme

After installing the Bootstrap Barrio theme using Composer, you'll need to create a subtheme to customize the look and feel of your website. To do this, follow these steps:

• Navigate to the Bootstrap Barrio starter kit folder by typing the following command in the terminal: cd web/themes/contrib/bootstrap_barrio/.
• Give execution permissions to the create_subtheme.sh script by typing the following command: chmod +x scripts/create_subtheme.sh.
• Execute the create_subtheme.sh script by typing the following command: ./scripts/create_subtheme.sh.
• When prompted, provide a machine name and human-readable name for your subtheme as follows.

The machine name of your custom theme? [e.g. mycustom_barrio]

mycustom_theme

Your theme name ? [e.g. My custom barrio]

My Custom Theme

After creating your subtheme by following the previous steps, you can locate it in the "themes/custom" folder.

Creating a subtheme allows you to customize the styling of your website while still utilizing the core functionality of the Bootstrap Barrio theme. With these steps, you'll have a subtheme created and ready to customize to your liking.

Step 3- Enable the Theme

To enable your custom theme that you have created using the above steps . Follow the below steps :

• To do this, go to the Appearance section of your Drupal site's admin panel.
• You should see a list of available themes in this section.
• Locate your custom theme in the list.
• Once you have found your theme, click on the "Install" button next to it.
• This will install your custom theme and make it available for use on your Drupal site.
• To make your custom theme the default theme for your site, click on the "Set as default" button next to your theme.
• This will activate your custom theme and set it as the default theme for your site.

After enabling your subtheme, you can start customizing its appearance and functionality to match your needs.

Here are a few ways you can customize your subtheme:

• Use the Drupal's admin panel to customize your subtheme's appearance by adjusting its settings and options.
• Modify your subtheme's CSS files to change its visual design.
• Add custom JavaScript code to enhance your subtheme's functionality.
• Implement custom templates to change the way content is displayed on your website.
• Add or remove functionality using Drupal modules or by creating custom modules.

By customizing your subtheme, you can make it unique and tailored to your specific requirements.

An Example Customization

With your custom Bootstrap theme set up and enabled, you can begin using it to create your website or application. To use the Bootstrap library as-is, simply start creating your website or application, leveraging the various pre-built components and features provided by Bootstrap.

However, if you want to customize the look and feel of your Bootstrap theme to better suit your needs, you can do so using the various customization options available in Drupal and Bootstrap.

For example, you can modify the CSS files of your custom Bootstrap theme to change the colors, fonts, and other visual aspects of your website or application. You can also add custom JavaScript code to your theme to enhance its functionality and add interactive features, while also modify the various templates used by your theme to change the way content is displayed on your site.

Here’s an example of changing some default styles by adding custom css to the styles.css

Open /web/themes/custom/[yourthemename]/css/style.css in your code editor.

Paste this code at the end of the file: 

Save the file, the browser should refresh automatically.

Here is the sample screenshot  before applying custom css.

Here is the sample screenshot after applying custom css.

Conclusion

Drupal theming with Bootstrap 5 in Drupal 8/9/10 is not only powerful but also flexible, providing endless possibilities for creating custom, responsive websites and applications. So whether you are building a simple blog or a complex web application, mastering Drupal theming with Bootstrap 5 is a skill that can take your web development to the next level.

We hope that this article has been helpful in getting you started with mastering Drupal theming with Bootstrap 5 in Drupal 8/9/10. With practice and experimentation, you can further enhance your skills and create stunning, responsive websites and applications that meet your needs and exceed your users' expectations.

Take your Drupal theming skills to the next level with Valuebound. Our expert team can guide you in mastering Drupal theming with Bootstrap 5, helping you create custom, responsive websites and applications that exceed your users' expectations. Contact us today to learn more!

Unit testing is an essential part of software development, and PHPUnit is a popular framework for testing PHP applications. In Drupal, PHPUnit is used to write and run automated tests for various components of the system. By writing tests with PHPUnit, developers can ensure that Drupal code is working as expected, catching bugs early and ensuring stable and reliable code. In this post, we'll walk through the steps of installing and setting up PHPUnit for Drupal 9/10, so you can start testing your Drupal code with ease.

What is PHPUnit?

PHPUnit is a unit testing framework for PHP, and it is used in Drupal to write and run automated tests for Drupal code. PHPUnit is used to test different components of the system, such as modules, themes, and core functionality. Writing tests with PHPUnit helps ensure that Drupal code is working as expected, making it easier to identify and fix bugs, and catch problems early to ensure that the code is stable and reliable.

Why use PHPUnit for automated unit testing in Drupal?

PHPUnit has several features which make it the best option for automated unit testing in Drupal. Some of these features include:

• Automated testing: PHPUnit allows for the creation of automated tests for Drupal code.
• Coverage analysis: PHPUnit generates reports that show how much of your Drupal code has been tested.
• Integration with Drupal: PHPUnit is integrated with Drupal's testing framework, making it easy to write and run tests for Drupal code.
• Community support: PHPUnit has a large community of developers who use it for testing Drupal code, providing many resources for learning and troubleshooting.
• Best practices: PHPUnit follows best practices for writing tests, such as using assertions to check code output, ensuring reliable and accurate tests.

How to install and setup PHPUnit for Drupal 9/10?

Step 1: Install Composer

PHPUnit is typically installed using composer, a dependency manager for PHP. You can download and install composer from their main website.

Step 2: Navigate to the root directory of your drupal project

Step 3: Require the PHPUnit module

Run the following command to install PHPUnit and it’s dependencies:

$ composer require --dev phpunit/phpunit:8.x --with-dependencies

Step 4: Install code coverage

We require xDebug for generating coverage reports. We can install it using the following command:

$ sudo apt-get install php7.4-xdebug

Step 5: Enable Xdebug

After installing Xdebug, you'll need to enable it in your PHP configuration file. To do this, open your php.ini (/etc/php/7.4/cli/php.ini) file and add the following line at bottom:

xdebug.mode=coverage

Step 6: Verification

To verify the correct installation, run php -v and check for the following output:

PHP 7.4.33 (cli) (built: Feb 14 2023 18:31:23) ( NTS )
 Copyright (c) The PHP Group
 Zend Engine v3.4.0, Copyright (c) Zend Technologies
   with Zend OPcache v7.4.33, Copyright (c), by Zend Technologies
   with Xdebug v3.1.6, Copyright (c) 2002-2022, by Derick Rethans   

The above line shows that Xdebug is enabled successfully.

Setting up PHPUnit for Drupal

Step 1: Creating the phpunit.xml file

Locate the phpunit.xml.dist file in the core folder of your drupal project. Copy and paste this file into your root directory and rename it to phpunit.xml.

Step 2: Creating simpl_test and browser_output directories

We need to create the two directories as mentioned above and assign the proper permissions to them. So run the following command to create them:

$ mkdir -p web/sites/simpletest/browser_output && chmod -R 777 web/sites/simpletest

Step 3: Requiring dependencies to resolve any errors

We may encounter an error related to dependencies upon running the tests. So to prevent this, run the below command to install them:

$ composer require behat/mink && composer require --dev phpspec/prophecy

Step 4: Verify for existing core tests

Once you have setup phpunit.xml, resolved all errors, and created the related directories, we can run PHPUnit test files using the following command from the root directory of your Drupal site:

$ ./vendor/bin/phpunit web/core/modules/user/tests/src/Unit/UserRegistrationResourceTest.php 

(This is for verifying existing drupal core test files)

You should get the following output in the snapshot below:

Step 5: Verification for coverage reports

To verify the coverage report process, we can run the following command:

$ ./vendor/bin/phpunit --coverage-html test-reports web/modules/custom/custom_module/ (coverage-html generates coverage report)

You should get an output similar to the snapshot below:

You may check the test reports in the test-reports folder in the root directory.

Writing a PHPUnit test

In this example, we create a service for fibonacci sequence related operations and write tests to check for the validity of these operations.

Step 1: Create a custom module in the custom folder

Follow path ‘\web\modules\custom\’. ‘custom_module’ is the name of the module here.

Step 2: Create the info.yml file for the custom module

Follow the code as below:

Step 3: Create the ‘Services’ folder for the module

Follow the folder structure as shown below

‘\web\modules\custom\custom_module\src\Services`

Step 4: Create the FibonacciService.php file within the ‘Services’ folder

The code for the service file is given as below.

The above service file defines two functions, viz.:

‘returnNumber’ gives a random number between 0-9.
‘calculateNthFibonacci’ takes in a number ‘n’ and gives the ‘nth’ term of the fibonacci sequence via recursion

Step 5: Create the directories for the unit tests

Follow the below structure to set it up

‘\web\modules\custom\custom_module\tests\src\Unit\Services’

This ‘Services’ folder is where we will put our unit test files.

Step 6: Create the test file

We can now create a file ‘FibonacciTest.php’ within `tests\src\Unit\Services’. 

The below code sets up the testing functions for the ‘FibonacciServices’ file:

setUp() is a method in PHPUnit that is called before each test method and is used to set up the test environment and prepare objects for the test. It is used to perform repetitive tasks required for each test case method, like initializing objects or connecting to databases.

testReturnNumber() is a custom method to test for the returnNumber() function in the previously created service file. We use assertTrue() to check for the number being between 0-9 by inserting our custom condition as the parameter.

testNthFibonacci() is a custom method to test for the calculateNthFibonacci() function in the previously created service file. We first call the service method to calculate the result and store it in a separate variable. Then we check for equality using assertEquals() to verify the calculation.

Step 7: Testing the module

Run the following command from the root directory of your project to perform the unit test:

$ ./vendor/bin/phpunit web/modules/custom/custom_module/

You will get an output as such:

This indicates that both of our tests were successful.

Conclusion

PHPUnit is an essential tool for writing and running automated tests for Drupal 9/10. By setting up and configuring PHPUnit, developers can catch bugs early and ensure that their code is stable and reliable. With the many features and benefits of PHPUnit, it's no wonder that it's the go-to choice for automated unit testing in Drupal. So why not get started with PHPUnit today?

If you need any help or guidance with installing or setting up PHPUnit for your Drupal projects, don't hesitate to reach out to the experts at Valuebound. Our team of experienced Drupal developers can help you with all your testing and development needs. Contact us today!

In a recent interview with Saurabh Bhardwaj, a Senior Software Developer at Valuebound, Content Manager Akanksha Mishra discussed a variety of topics related to building growth-oriented teams, technology leadership as a team lead, and more. During the conversation, Saurabh shared his personal experiences and technical challenges, which could serve as inspiration for aspiring software developers.

Team Management as a Team Lead at Valuebound

Q: Can you tell us about your experience as a software developer at Valuebound and how you became a Team Lead?

Saurabh: After joining VB as a senior software developer, I began working with my team immediately. Through hard work and dedication, my seniors and project manager began to trust me more and more. Eventually, they offered me the opportunity to lead a project, and together with my team, we were able to deliver high-quality work to our clients.

My strong leadership skills did not go unnoticed, and the management team recognized my potential. As a result, I was promoted to a leadership position, where I continue to excel in guiding my team toward success.

Q: How do you manage and motivate your team to achieve their goals?

Saurabh: To effectively manage my junior subordinates, I establish both professional and personal connections with them. I prioritize addressing any personal issues that may impact their work. When it comes to assignments, I allow my team to determine their own timelines and level of effort. Honesty is also key - I expect it from my team and make sure to reciprocate in kind.

To ensure my team achieves both their short-term and long-term goals, I guide them towards the right path. I regularly check in with team members to listen to their suggestions and help address any concerns. Additionally, I make sure everyone is compensated fairly based on their bands, which helps maintain motivation and morale.

Project Management: Overcoming Challenges & Navigating Solutions

Q: How do you prioritize tasks and allocate resources to ensure timely delivery of projects?

Saurabh: Our project management systems feature a robust tagging system that allows us and our clients to identify task priorities. Depending on a task's complexity and duration, I may break it down into smaller sub-tasks.
When allocating resources, I prioritize assigning tasks that challenge my team members and help them learn and grow. I also ensure that the difficulty level of the task aligns with their band. If a team member requires assistance, the entire team is always available to provide support.

I firmly believe that the speed of the team is determined by its slowest member. As a result, I prioritize helping all members of the team improve their skills and abilities to ensure that we can continue delivering high-quality work efficiently.

Q: Can you walk us through a recent project you led, highlighting the challenges and how you overcame them?

Saurabh: During my recent oversight of one of the projects for a client, a significant flaw was discovered as we were preparing to deliver the project. I immediately reached out to my team to discuss the issue and the necessary steps to rectify it. Honesty and integrity were vital in this process, and we all acknowledged that we may have missed something in the beginning. We worked collaboratively to fix the issue and successfully delivered the project on time. The success of this effort was a testament to our team's cohesion and management.

We took this experience as a learning opportunity and identified areas where we missed important details. We made sure to avoid making the same mistakes in future projects by creating more robust architecture and development plans. We were able to complete the next project well before the deadline.

When I reported the flaw in the project to my seniors, they were supportive and encouraged me to find a solution. Their motivation helped me to remain focused on finding a solution and addressing the issue with my team.

WebRTC Project Success

Q: Can you provide an overview of the WebRTC project you successfully worked on? What were the main goals and objectives of the project, and how did you ensure they were met?

Saurabh: We recently received a client request to enable one-way audio, video, and screen broadcasting from teachers to students. Our primary challenge was to ensure scalability, reliability, and cost-effectiveness of the project.

To address these challenges, we developed a custom, reliable, and cost-effective solution using Mediasoup media servers. This technology is based on webRTC, but designed for larger-scale applications that require higher scalability and reliability.

To implement the project, we used different technology stacks. Our primary application was built in Drupal, while the teacher's side was developed using React JS for better performance. The media servers were built entirely in Node JS. Overall, this approach proved successful in meeting the client's requirements and ensuring a reliable, scalable, and cost-effective solution.

Q: How did you approach testing and debugging for the WebRTC project? What tools and technologies did you use to develop the WebRTC project?

Saurabh: To test the webRTC feature, we initially explored several vendors who offered testing services for webRTC. However, we found that their services were quite expensive. To overcome this challenge, we decided to write our own automated test scripts using Java for all leading browsers.

The results of our testing were extremely satisfying. With our own test scripts, we were able to test for up to 2000 concurrent users at a given time, and without incurring the high costs of external vendors. Overall, this approach allowed us to thoroughly test our webRTC feature and ensure its reliability and scalability.

Q: How did you ensure the WebRTC project was scalable and able to handle large amounts of traffic?

Saurabh: Since we were using a custom-built media server solution, we were confident that we could scale the application to meet our needs. Scaling the application simply requires choosing hardware that can support the increased demand. The larger and more powerful the hardware we use, the more capable our application becomes. With this level of control over our hardware, we are able to ensure that our application can handle any level of demand with ease.

Q: Can you share any best practices or tips for others who are working on WebRTC projects?

Saurabh: Open source media server libraries are becoming increasingly popular in the market due to their ease of implementation and well-documented functionalities. We used MediaSoup, an open source media server library, for our application and found it to be a great tool for developing cost-effective solutions for clients. Not only do these libraries provide cost-effective solutions, but they also provide ample opportunities to learn while developing such applications.

Tips and Suggestions for Aspiring Software Developers

Q: How do you stay up-to-date with the latest software development trends and technologies?

Saurabh: To remain current with the latest technologies, I consistently follow numerous technical blogs and engage in healthy discussions with my team. Recently, I initiated a program wherein each team member is encouraged to learn something new every week and share it with the rest of the team. This initiative has been beneficial in keeping the entire team up-to-date with emerging technologies and trends.

Q: What advice would you give to aspiring software developers looking to become Team Leads?

Saurabh: I continually strive to become a better team lead, and I believe that honesty is key to achieving this. I maintain transparency with my team and treat all members with respect, ensuring that everyone is treated equally.

I make an effort to listen to the concerns of my team members and assist them in resolving any issues, whenever possible. Regular follow-ups are part of my management style, ensuring that team members remain on track and avoid delays. Proactively identifying potential roadblocks that may impact their work is also something that I prioritize, working to prevent potential issues before they arise.

Conclusion

Saurabh Bhardwaj, a Senior Software Developer at Valuebound, shared valuable insights on building growth-oriented teams and overcoming technical challenges. It's clear that Valuebound's culture values employee development and innovation. If you're interested in learning more about the company's culture and reading more interviews with employees, check out our website.

Dynamic routing is a key aspect of Drupal's flexible and extensible architecture that allows developers to define their own routes dynamically. This feature can be particularly useful when creating custom plugins, which can have unique routes to present their forms to users.

Implementing dynamic routing can be a powerful tool for customizing your website's functionality. By defining custom plugin types and their associated route callbacks, you can create complex, dynamic URLs that respond to user input and interact with your website's content in meaningful ways.

In this guide, we'll explore the ins and outs of implementing dynamic routing in Drupal, with a focus on the creation and use of custom plugin types and their associated route callbacks. Whether you're new to Drupal development or an experienced pro, this guide will help you master the art of dynamic routing and take your website's functionality to the next level.

Guide to implement dynamic routing in Drupal with custom plugin types

To implement dynamic routing in Drupal with custom plugin types, you need to follow these steps:

Step 1: Add 'route_callbacks' in the module's routing.yml file

Create a routing class that defines the dynamic routes for each plugin. This class should use the WebUtilityPluginManager service to get the definitions of all the custom plugins and create a new Route object for each one.

Add a display controller that renders the plugin form for the dynamic route. This controller should use the WebUtilityInterface service to load the plugin's configuration and content, and the FormBuilderInterface service to generate the plugin form.

Overall, dynamic routing in Drupal allows developers to create more flexible and customizable websites by defining their own routes and providing unique user experiences for each route.

Step 2: Implementation

1. Add 'route_callbacks' in modules routing.yml

route_callbacks:
 - '\Drupal\example\Routing\ExampleRoutes::routes'

2. Create a routing class

3. Add display controller

Conclusion

Dynamic routes and route callbacks are powerful features of the Drupal CMS that allow developers to create custom paths and define their own logic for handling those paths. Dynamic routes are used to create paths with placeholders that can be replaced with variable values at runtime, while route callbacks define the logic for handling those paths and returning a response.

Hence, dynamic routing in Drupal is a powerful tool for creating custom functionality on your website. By defining custom plugin types and their associated route callbacks, you can create URLs that respond to user input and interact with your website's content in meaningful ways. Whether you're building a simple blog or a complex e-commerce site, dynamic routing can help you create a better user experience and improve your website's functionality.

If you're looking for help implementing dynamic routing in Drupal, Valuebound is here to help. Our team of Drupal experts can work with you to create custom plugin types and route callbacks that meet your website's unique needs. Contact us today to learn more about our Drupal development services and how we can help take your website to the next level.

In today's digital age, it's essential to ensure that websites are accessible to everyone. This includes people with disabilities, such as visual or hearing impairments, as well as those who rely on assistive technology like screen readers. In this article, Valuebound CEO & Founder, Neeraj explores recommendations for creating accessible websites with Drupal, a popular open-source content management system.

Recommendations on creating accessible websites with Drupal

By implementing these recommendations, you can create an accessible website that provides a better user experience for all users.

Conclusion

Creating accessible websites is crucial for ensuring that everyone can access digital content, and Drupal provides many features and tools to help make websites more accessible. By following these tips and best practices, you can create websites that are user-friendly and inclusive for everyone. 

Ultimately, prioritizing accessibility in website design benefits both users and organizations, as it improves the overall user experience, fosters greater inclusivity, and enhances brand reputation.

Are you looking to create accessible websites that cater to a diverse range of users? Look no further! Contact us at Valuebound to speak with our team of Drupal experts. We can help you implement accessibility best practices and leverage Drupal's features to create an inclusive and user-friendly experience for all. Let's work together to build a better digital world for everyone.

Drupal is a flexible content management system that allows you to create and manage various content types. One of the powerful features of Drupal is entity reference, which allows you to create relationships between different types of content on your website. Entity reference can be useful for data management, organization, and enhancing user experience.

In this article, we will explore how to use entity reference in Drupal with a practical coding example.

Understanding Entities in Drupal

Entities are self-contained data units with unique identifiers in Drupal. Examples of entities include nodes, users, and taxonomy terms. Entities help Drupal manage content in a structured way, and you can define entities and their properties to create custom content types that meet your needs.

What is Entity Reference?

Entity reference is a Drupal module that allows you to create relationships between different types of entities on your website. With entity reference, you can link one entity to another, even if they are different types of entities. For instance, you can link an article to an author or a product to a category.

Using Entity Reference in Drupal

Here is a step-by-step guide on how to use entity reference in Drupal:

1. Install the Entity Reference module: First, install the Entity Reference module from the Drupal module repository or using Composer. You can install the module using Composer with the following command: 

   composer require drupal/entity_reference

2. Create your content types: Next, create the content types you want to link together. For this example, we will create two content types, "Event" and "Speaker". To create the content types, navigate to the Content Types page in Drupal's administrative interface and select "Add content type."
3. Add a reference field: After creating the content types, add a reference field to one of them. For instance, add a "Speaker" reference field to the "Event" content type. To do so, navigate to the "Manage fields" page of the "Event" content type and click "Add field". Choose "Entity reference" as the field type, and set the "Target type" to "Speaker".
4. Configure the reference field: Configure the reference field by selecting how many values are allowed, whether the field is required, and other settings. For example, you can limit the reference field to one speaker or allow multiple speakers to be referenced.
5. Link your content: Finally, link the content types together. When creating a new "Event" entity, select the speaker(s) who will be presenting at that event. Once you have saved the entity, the speaker(s) will be linked to the event.

Here is an example code snippet showing how to create an entity reference field in Drupal programmatically:

There are several benefits of using entity reference in Drupal:

1. Better Data Management: Entity reference allows you to establish relationships between different types of content, which can help you better organize and manage your data.
2. Enhanced User Experience: With entity reference, you can create dynamic pages that show related content to users. For example, if a user is viewing an article, you can display other articles by the same author.
3. Increased Flexibility: Entity reference allows you to create custom content types that meet your specific needs. You can define your own entities and their properties to suit your requirements.

Conclusion

Drupal entity reference is a powerful tool that allows you to link different types of content together. By establishing relationships between entities, you can create a more structured and organized website that offers a better user experience. Hopefully, this article has given you a better understanding of how entity reference works in Drupal and how you can use it to enhance your data management capabilities.

Valuebound is proud to announce the success of our recent Drupal Meetup 2023, held at our Bangalore office. The event was a gathering of talented Drupal developers from different companies who came together to share knowledge, discuss best practices, and explore innovative solutions using Drupal and open source technologies. The event provided attendees with valuable insights into Drupal and showcased the versatility of open source technologies.

The event featured four insightful sessions led by experienced professionals, including "IaC with Terraform" by Wilfred Arambhan and Santhosh Kumar, "Dynamic routes and route_callback in Drupal 10" by Indra Patil, "Best Practices for HIPAA-Compliant Drupal Platform" by Wilfred Arambhan, and "PHPUnit Test Casing in Drupal" by Sidharth Soman. Each presentation provided attendees with valuable knowledge and showcased the versatility of Drupal and open source technologies.

Valuable Knowledge Shared

During the "IaC with Terraform" session, Wilfred Arambhan and Santhosh Kumar discussed how Infrastructure as Code (IaC) can help automate the process of creating, modifying, and deleting infrastructure. The session highlighted the benefits of using Terraform as a tool for implementing IaC.

In the "Dynamic routes and route_callback in Drupal 10" session, Indra Patil shared insights into Drupal 10's new routing system. The session provided attendees with valuable knowledge on how to leverage Drupal 10's dynamic routing capabilities.

Wilfred Arambhan's "Best Practices for HIPAA-Compliant Drupal Platform" session focused on the importance of HIPAA compliance when building Drupal websites that handle sensitive healthcare data. The session highlighted the best practices for building a secure and compliant Drupal platform.

Lastly, Sidharth Soman's "PHPUnit Test Casing in Drupal" session provided attendees with insights into Drupal's testing framework, PHPUnit. The session provided valuable knowledge on how to write effective tests for Drupal code.

Opportunities for Networking and Collaboration

The event was not just about the presentations but also provided attendees with the opportunity to network, exchange ideas, and explore potential collaborations. Participants had the chance to meet and connect with other Drupal developers, share ideas, and discuss potential projects.

Valuebound's Commitment to Open Source Technology

At Valuebound, we are passionate about open source technology and remain committed to supporting the Drupal ecosystem. The success of the Bangalore Drupal Meetup is a testament to our dedication to empowering developers and advancing open source initiatives. We believe that these events provide a platform for developers to learn, share knowledge and ideas, and build connections.

Gratitude to Participants

We would like to extend our heartfelt gratitude to everyone who participated in the event and contributed to its success. Without your participation, the event would not have been possible. We look forward to hosting more Drupal and open source-focused events in the future, and we encourage you to stay connected with us for updates on upcoming gatherings.

Conclusion

The Bangalore Drupal Meetup was a great success, providing attendees with valuable knowledge and insights into Drupal and open source technologies. The event highlighted the versatility of Drupal and the potential of open source technologies. Valuebound remains committed to supporting the Drupal ecosystem and providing a platform for developers to learn, share knowledge and ideas, and build connections. We look forward to hosting more events in the future and encourage you to stay connected with us for updates.