Team Management

We have been learning quite a lot about Dapr now. These are some of my previous articles about Dapr Workflows and Dapr Conversation AI components. Today, we will discuss Jobs, another important building block of the Dapr ecosystem. Many times, you will need to run workflows on a schedule. For example, Regular file backups: Periodic backups help restore data when there is a failure. So, you could schedule one to back up your data on a regular basis.Performing maintenance tasks: Things like file cleanups, recycling VM nodes, and batch processing data are some other scenarios where Dapr Jobs can help. Jobs Architecture MyApp is the Java application we will be creating today, responsible for scheduling and registering the job.When creating the cron job, the application needs to register a callback endpoint so that the Dapr runtime can invoke it at the scheduled time. The endpoint should be a POST request with a URL pattern similar to /jobs/{jobName}, where jobName corresponds to the name used when registering the job. Now, let's look at a practical demonstration. In the sample app, we will create a simple job that runs every 10 seconds. The callback URL registered will print the name of the job that is being invoked.Because we have used .NET SDK in all the previous articles, this time we will go with the java-sdk. Step 1 Download the Dapr CLI and install it. There is also an MSI that you could use to install the latest version here: https://github.com/dapr/cli/releases. PowerShell powershell -Command "iwr -useb https://raw.githubusercontent.com/dapr/cli/master/install/install.ps1 | iex" Step 2 Verify the installation using the following command. PowerShell dapr -h Make sure you have Docker running too because the cli downloads docker images of runtime, scheduler and placement services. Next, it is time to set up the app. For this, we will create a maven project and use the dapr maven dependencies. Gradle could be another choice. Step 3 Create a Maven project. Add the following Dapr dependency to it. Java <dependency> <groupId>io.dapr</groupId> <artifactId>dapr-sdk</artifactId> <version>${project.version}</version> </dependency> We also discussed registering an endpoint that the scheduler could call. In this case, we are using the Spring framework to register an endpoint. You could also use JAX-RS or any other framework of your choice. Java <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${springboot.version}</version> </dependency> Step 4 App logic to register the job. Java import io.dapr.client.DaprClientBuilder; import io.dapr.client.DaprPreviewClient; import io.dapr.client.domain.GetJobRequest; import io.dapr.client.domain.GetJobResponse; import io.dapr.client.domain.JobSchedule; import io.dapr.client.domain.ScheduleJobRequest; import io.dapr.config.Properties; import io.dapr.config.Property; import java.util.Map; public class DemoJobsClient { /** * The main method of this app to register and fetch jobs. */ public static void main(String[] args) throws Exception { Map<Property<?>, String> overrides = Map.of( Properties.HTTP_PORT, "3500", Properties.GRPC_PORT, "51439" ); try (DaprPreviewClient client = new DaprClientBuilder().withPropertyOverrides(overrides).buildPreviewClient()) { // Schedule a job. System.out.println("**** Scheduling a Job with name dapr-jobs *****"); ScheduleJobRequest scheduleJobRequest = new ScheduleJobRequest("dapr-job", JobSchedule.fromString("*/10 * * * * *")).setData("Hello World!".getBytes()); client.scheduleJob(scheduleJobRequest).block(); System.out.println("**** Scheduling job with name dapr-jobs completed *****"); // Get a job. System.out.println("**** Retrieving a Job with name dapr-jobs *****"); GetJobResponse getJobResponse = client.getJob(new GetJobRequest("dapr-job")).block(); // Delete a job. DeleteJobResponse deleteJobResponse = client.deleteJob(new DeleteJobRequest("dapr-job")).block(); } } } We have created a simple Java class with a main method. Because Jobs is still a preview feature, DaprPreviewClient is used to schedule, get, or delete a Job.The ScheduleJobRequest constructor takes in two parameters, the name of the job and the cron expression, which in this case is to run every 10 seconds. Finally, we call the scheduleJob() method that will schedule a job with the Dapper runtime.The getJob() method is used to retrieve the job details of an existing job. Step 5 Register a callback endpoint. Java import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import reactor.core.publisher.Mono; /** * SpringBoot Controller to handle jobs callback. */ @RestController public class JobsController { /** * Handles jobs callback from Dapr. * * @param jobName name of the job. * @param payload data from the job if payload exists. * @return Empty Mono. */ @PostMapping("/job/{jobName}") public Mono<Void> handleJob(@PathVariable("jobName") String jobName, @RequestBody(required = false) byte[] payload) { System.out.println("Job Name: " + jobName); System.out.println("Job Payload: " + new String(payload)); return Mono.empty(); } } Once it is time to run the scheduled job, the Dapr runtime will call the following endpoint. You could define a PostMapping with the specific Job name like "/job/dapr-job" or use a path param like we did above. Step 6 Write the startup file for the Spring Boot app. Java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; /** * Spring Boot application to demonstrate Dapr Jobs callback API. * <p> * This application demonstrates how to use Dapr Jobs API with Spring Boot. * </p> */ @SpringBootApplication public class DemoJobsSpringApplication { public static void main(String[] args) throws Exception { SpringApplication.run(DemoJobsSpringApplication.class, args); } } Step 7 Now, it is time to run the application. Go to the Maven project folder and run the following command. Change the name of the jar and class if required. PowerShell dapr run --app-id myapp --app-port 8080 --dapr-http-port 3500 --dapr-grpc-port 51439 --log-level debug -- java -jar target/dapr-java-sdk-examples-exec.jar io.dapr.examples.jobs.DemoJobsSpringApplication Output from the command. Step 8 Finally, run the DemoJobsClient. PowerShell java -jar target/dapr-java-sdk-examples-exec.jar io.dapr.examples.jobs.DemoJobsClient Output from the command. Plain Text **** Scheduling a Job with name dapr-jobs ***** Switching back to the other window where we ran the command from Step 8, you will notice the following console log. Plain Text == APP == Job Name: dapr-job == APP == Job Payload: Hello World! Conclusion Dapr Jobs is a powerful tool that can help you schedule workloads without having to take the complexity of using CRON libraries. Go try it out.

By Siri Varma Vegiraju CORE

Editor's Note: The following is an article written for and published in DZone's 2024 Trend Report, Observability and Performance: The Precipice of Building Highly Performant Software Systems. "Quality is not an act, it's a habit," said Aristotle, a principle that rings true in the software world as well. Specifically for developers, this means delivering user satisfaction is not a one-time effort but an ongoing commitment. To achieve this commitment, engineering teams need to have reliability goals that clearly define the baseline performance that users can expect. This is precisely where service-level objectives (SLOs) come into picture. Simply put, SLOs are reliability goals for products to achieve in order to keep users happy. They serve as the quantifiable bridge between abstract quality goals and the day-to-day operational decisions that DevOps teams must make. Because of this very importance, it is critical to define them effectively for your service. In this article, we will go through a step-by-step approach to define SLOs with an example, followed by some challenges with SLOs. Steps to Define Service-Level Objectives Like any other process, defining SLOs may seem overwhelming at first, but by following some simple steps, you can create effective objectives. It's important to remember that SLOs are not set-and-forget metrics. Instead, they are part of an iterative process that evolves as you gain more insight into your system. So even if your initial SLOs aren't perfect, it's okay — they can and should be refined over time. Figure 1. Steps to define SLOs Step 1: Choose Critical User Journeys A critical user journey refers to the sequence of interactions a user takes to achieve a specific goal within a system or a service. Ensuring the reliability of these journeys is important because it directly impacts the customer experience. Some ways to identify critical user journeys can be through evaluating revenue/business impact when a certain workflow fails and identifying frequent flows through user analytics. For example, consider a service that creates virtual machines (VMs). Some of the actions users can perform on this service are browsing through the available VM shapes, choosing a region to create the VM in, and launching the VM. If the development team were to order them by business impact, the ranking would be: Launching the VM because this has a direct revenue impact. If users cannot launch a VM, then the core functionality of the service has failed, affecting customer satisfaction and revenue directly.Choosing a region to create the VM. While users can still create a VM in a different region, it may lead to a degraded experience if they have a regional preference. This choice can affect performance and compliance.Browsing through the VM catalog. Although this is important for decision making, it has a lower direct impact on the business because users can change the VM shape later. Step 2: Determine Service-Level Indicators That Can Track User Journeys Now that the user journeys are defined, the next step is to measure them effectively. Service-level indicators (SLIs) are the metrics that developers use to quantify system performance and reliability. For engineering teams, SLIs serve a dual purpose: They provide actionable data to detect degradation, guide architectural decisions, and validate infrastructure changes. They also form the foundation for meaningful SLOs by providing the quantitative measurements needed to set and track reliability targets. For instance, when launching a VM, some of the SLIs can be availability and latency. Availability: Out of the X requests to launch a VM, how many succeeded? A simple formula to calculate this is: If there were 1,000 requests and 998 requests out of them succeeded, then the availability is = 99.8%. Latency: Out of the total number of requests to launch a VM, what time did the 50th, 95th, or 99th percentile of requests take to launch the VM? The percentiles here are just examples and can vary depending on the specific use case or service-level expectations. In a scenario with 1,000 requests where 900 requests were completed in 5 seconds and the remaining 100 took 10 seconds, the 95th percentile latency would be = 10 seconds.While averages can also be used to calculate latencies, percentiles are typically recommended because they account for tail latencies, offering a more accurate representation of the user experience. Step 3: Identify Target Numbers for SLOs Simply put, SLOs are the target numbers we want our SLIs to achieve in a specific time window. For the VM scenario, the SLOs can be: The availability of the service should be greater than 99% over a 30-day rolling window.The 95th percentile latency for launching the VMs should not exceed eight seconds. When setting these targets, some things to keep in mind are: Using historical data. If you need to set SLOs based on a 30-day rolling period, gather data from multiple 30-day windows to define the targets. If you lack this historical data, start with a more manageable goal, such as aiming for 99% availability each day, and adjust it over time as you gather more information. Remember, SLOs are not set in stone; they should continuously evolve to reflect the changing needs of your service and customers. Considering dependency SLOs. Services typically rely on other services and infrastructure components, such as databases and load balancers. For instance, if your service depends on a SQL database with an availability SLO of 99.9%, then your service's SLO cannot exceed 99.9%. This is because the maximum availability is constrained by the performance of its underlying dependencies, which cannot guarantee higher reliability. Challenges of SLOs It might be intriguing to set the SLO as 100%, but this is impossible. A 100% availability, for instance, means that there is no room for important activities like shipping features, patching, or testing, which is not realistic. Defining SLOs requires collaboration across multiple teams, including engineering, product, operations, QA, and leadership. Ensuring that all stakeholders are aligned and agree on the targets is essential for the SLO to be successful and actionable. Step 4: Account for Error Budget An error budget is the measure of downtime a system can afford without upsetting customers or breaching contractual obligations. Below is one way of looking at it: If the error budget is nearly depleted, the engineering team should focus on improving reliability and reducing incidents rather than releasing new features.If there's plenty of error budget left, the engineering team can afford to prioritize shipping new features as the system is performing well within its reliability targets. There are two common approaches to measuring the error budget: time based and event based. Let's explore how the statement, "The availability of the service should be greater than 99% over a 30-day rolling window," applies to each. Time-Based Measurement In a time-based error budget, the statement above translates to the service being allowed to be down for 43 minutes and 50 seconds in a month, or 7 hours and 14 minutes in a year. Here's how to calculate it: Determine the number of data points. Start by determining the number of time units (data points) within the SLO time window. For instance, if the base time unit is 1 minute and the SLO window is 30 days: Calculate the error budget. Next, calculate how many data points can "fail" (i.e., downtime). The error budget is the percentage of allowable failure. Convert this to time: This means the system can experience 7 hours and 14 minutes of downtime in a 30-day window. Last but not least, the remaining error budget is the difference between the total possible downtime and the downtime already used. Event-Based Measurement For event-based measurement, the error budget is measured in terms of percentages. The aforementioned statement translates to a 1% error budget in a 30-day rolling window. Let's say there are 43,200 data points in that 30-day window, and 100 of them are bad. You can calculate how much of the error budget has been consumed using this formula: Now, to find out how much error budget remains, subtract this from the total allowed error budget (1%): Thus, the service can still tolerate 0.77% more bad data points. Advantages of Error Budget Error budgets can be utilized to set up automated monitors and alerts that notify development teams when the budget is at risk of depletion. These alerts enable them to recognize when a greater caution is required while deploying changes to production. Teams often face ambiguity when it comes to prioritizing features vs. operations. Error budget can be one way to address this challenge. By providing clear, data-driven metrics, engineering teams are able to prioritize reliability tasks over new features when necessary. The error budget is among the well-established strategies to improve accountability and maturity within the engineering teams. Cautions to Take With Error Budgets When there is extra budget available, developers should actively look into using it. This is a prime opportunity to deepen the understanding of the service by experimenting with techniques like chaos engineering. Engineering teams can observe how the service responds and uncover hidden dependencies that may not be apparent during normal operations. Last but not least, developers must monitor error budget depletion closely as unexpected incidents can rapidly exhaust it. Conclusion Service-level objectives represent a journey rather than a destination in reliability engineering. While they provide important metrics for measuring service reliability, their true value lies in creating a culture of reliability within organizations. Rather than pursuing perfection, teams should embrace SLOs as tools that evolve alongside their services. Looking ahead, the integration of AI and machine learning promises to transform SLOs from reactive measurements into predictive instruments, enabling organizations to anticipate and prevent failures before they impact users. Additional resources: Implementing Service Level Objectives, Alex Hidalgo, 2020 "Service Level Objects," Chris Jones et al., 2017 "Implementing SLOs," Steven Thurgood et al., 2018 Uptime/downtime calculator This is an excerpt from DZone's 2024 Trend Report, Observability and Performance: The Precipice of Building Highly Performant Software Systems.Read the Free Report

By Siri Varma Vegiraju CORE

There’s a common career progression in this technical industry. You come in wet behind the ears as a junior developer, whether front-end, back-end, infrastructure, or even security. After a few years, you lose the “junior” from your title, and after a few more years, you gain a “senior.” You might become a team lead after that with some light duties around oversight and overall team delivery. But then you’re promoted into some role with "manager" in the title — engineering manager or software development manager or something similar. Suddenly, you’re in a position where it’s pretty easy to prove out the Peter principle. Wikipedia summaries this principle, coined in a 1969 book, as follows: “The Peter principle is a concept in management developed by Laurence J. Peter which observes that people in a hierarchy tend to rise to 'a level of respective incompetence': Employees are promoted based on their success in previous jobs until they reach a level at which they are no longer competent, as skills in one job do not necessarily translate to another.” Skills as a successful software engineer in no way prepare you for the duties of management —and not just any kind of management, but people management. There are so many ways this goes wrong that a million and one books, articles, training programs, and Substack posts are out there to help people figure out how to become better managers. So why this article — and why me? Though I’ve worn many hats in my career, for most of it I should have had the title “reluctant manager.” Management?! I’d rather slit my throat. Can’t I just do it all myself? Maybe you’re not like me and have always wished for minions around to do your bidding, but you’ve found they’re a little harder to, well, manage, than you expected. I’m Amanda Kabak, Founder of Verdant Work, and I’ve been in the industry for over 25 years, spending the last decade of that in startups and ending as the CTO of a clean-energy software company. I’ve built and managed teams with limited resources and varying degrees of naivete, but I learned how to lead disparate groups of people to repeated successes in delivery while maintaining good retention and a sunny disposition. This series of articles is specifically geared toward technically minded people who have found themselves in the limelight of team or department management and need some straightforward and pragmatic help to excel in this role as you had done as an individual contributor. What Is Management? One of the core tenets of all effective management is clear communication, so let’s make sure we’re all in agreement as to what we mean when we talk about management. For me, if I’m feeling cheeky, which I usually am, I think of management as the title of this article: "Getting Shit Done Without Doing It Yourself." But, seriously, Merriam Webster so helpfully defines it as “the conducting or supervising of something (such as a business).” What about “facilitating the work and professional maturity of those who report to you”? Is everyone familiar with Maslow’s hierarchy of needs? In management, I focus on the bottom two layers: physical needs and safety, with a touch of the next one, belonging. I have to admit that physical needs and safety are partly metaphors, but they’re really good metaphors as well as being concretely accurate as well. Physical needs: do they have the right equipment? Do they feel comfortable talking to people inside and external to the team? Do they have proper bandwidth and aren’t freezing for sweltering in an out-of-the-way corner of the office? Are they sick and need to take the afternoon off? It’s as easy as that. Ask how they’re doing. Introduce them around. Sit in on a few meetings. Make them log off when they’re hacking up a lung or have brain fog from allergies or sleep deprivation. Now safety, on the other hand, is a little more complex. There’s a physical component to it, yes — but I’m largely concerned with a feeling of security. Can they ask questions? Do they feel empowered to make decisions? Do they fear punishment for doing something wrong? This kind of safety is key to continued performance and growth. Finally, belonging. This one is less concrete than the other two, but the other two enable it to happen, just like in that triangle. If you want a hokey word for it, I would say that we’re looking for synergy: getting more out of individual parts when they’re together. Do you facilitate a feeling of camaraderie on the team? Do team members actively ask for help from each other or you? Do you acknowledge wins and learn together from losses? I’ll touch on this more later, but, remember, you can’t have this if you haven’t met physical needs and safety first. Context Everything in life has a context, which means nothing happens in a vacuum — everything happens within, next to, or during something else. In literature, there are schools of criticism that not only dive deeply into the words on the page (the what) but into what was going on while it was written, the politics in play, the social mores, the epidemics, and wars. This is all context — and guess what? When you give someone a task, there’s a context to it, whether you divulge it or not, and this context is critical for everyone to understand. “What,” alone, is insufficient. Think about the game of Clue, if that’s not dating me too much. Colonel Mustard in the Conservatory with the candlestick. For a story to be complete, it’s not just about what. It’s about who, where, and most importantly, why. What is the business perspective of the task you’re assigning? Who are the customers that need this feature? Why do they need it? How do our competitors handle it? Where does it sit on the larger roadmap? How does it potentially relate to revenue targets? In many cases, users pay your salary, and you and your team are likely one of the most expensive things in the company. Don’t forget them, and don’t let your team forget them. Is everyone clear on how this task relates to others that are happening at the same time? Do they understand where this piece of functionality fits into the larger flow? Are they aware of upstream or downstream integrations they may have to take into account for timing and compatibility? Think about an assembly line: each step is dependent on the step before it is completed successfully and to specification, and the step after this one expects a certain outcome before it can begin. Another kind of context is in your team’s history. It can help to point out things you’ve done before that are similar as well as those that are different. These can provide concrete frames of reference for the work you’re assigning. Document the Details Details are an essential part of good communication. First and most importantly, what is in or out of scope? Let me tell you something: scope is not like Schrodinger’s Cat. You need to know what’s in that box before you open it. If it’s your team member’s job to find out, then that’s a task in and of itself. And, guess what? What is in or out of scope needs to be documented somewhere outside your head, their head, or the business owner’s head. What do I mean by document? I mean something tangible and complete. I don’t care if it’s a Post-It note or a printed and bound novel, though I would caution against both. The key here is that multiple people can point at it and be looking at the same thing. But be cautious about handing over dense blocks of text. Diagrams are awesome, maybe throw in a table or two where it makes sense. Bullet points can help delineate text to make it more digestible; numbering the list facilitates fast referencing for discussion. Look at these two pages. Which do you think is easier for people to digest? Right. The second one. Bullet points are powerful, images are even more so. You know the old adage that an image is worth a thousand words? This is especially true in requirements. You don’t want everyone to have a different picture in their mind; the only way to avoid that is to put the picture on the page. Whatever you do for your documentation and wherever you store it — your GDrive, SharePoint, ADO, Jira, GitHub, the closest conference room — be consistent. Define a set of standards and then use them. Standards not only help organize, but they make the content easier to absorb and can help you ensure everything is complete. If you’ve got a blank space for security concerns in your template, you might remember to ask about it. . . and it might even get implemented. The Definition of Done For any task, you need to know what you’re doing and hopefully why, but you also need to know when you’re finished. Done is this nirvana that never lasts, but for the brief moments we’re there, everything can seem worth it. You could think of it like a home improvement project you’re contracting out. If the contractor wants 50% in the middle of the project and the rest when it’s complete, you’re all going to agree that once the plumbing is roughed in and the tile is up, you’ll pull out your checkbook. That 50% mark has to be defined. The definition of done can be thought of as just another tool of communication. Why are increments of doneness important — besides contractors getting paid? They enforce agreement. If everyone knows where a task is supposed to end before it starts, we can all focus on the work and not on trying to patch up mismatched expectations. Let me say it this way: if someone doesn’t know what’s expected of them, how can they possibly succeed?They enforce process. If 75% of your tasks have a common set of items that must be completed — tests, for example — you can automate these requirements and make your tool require them. People will get used to including them pretty quickly if the PR can’t be made or the build fails. Steps of review and approval should be in place where appropriate.They promote quality. Think of what doneness should look like for this task. What about tests? What about documentation? What about review? Think of all those things that we say we’ll do later “when things slow down.” What if we require them from the start? Because it takes too long? How long does it take for us to fix integration or production bugs or not understand why something was implemented in a certain way?They communicate progress. If something is actually done, meeting all the criteria of doneness, you can. . . call it done! You can communicate that this nugget of business value has been achieved, and you can see where you really are in your project because of it. If something is almost done or kind of done or done except for this one thing, guess what? It’s not done, and you shouldn’t claim credit for it, no matter how much you might want to. It’s the painful truth. Finished, done, is a binary state, which means if it’s not yes, it’s no.They enable a feeling of success. If our work overall is never done, when can we ever have that pizza party? I’m serious. If we are on a hamster wheel of never-ending sprints and continuous releases, when are we supposed to feel satisfied and take a breath? I’m serious about this, too. A long grind induces burnout, which brings about turnover, which loses the company money on retraining and kills days of your time in interviewing and onboarding.They provide moments of reflection. If something goes wrong with a task, everyone knows it by the time you get to done, and you can disseminate that knowledge across the team quickly and make adjustments so it doesn’t happen again — even in the same project, maybe even in the same Sprint. If something goes really right, it’s an opportunity to see it and respond to it right away. So much goodness in true doneness. That’s why one of the most important aspects of this is that you cannot compromise on your definition of done. You just can’t. If the buck stops at you, why would you want to? Because you’re under pressure? Who isn’t? Making sure things are done the right way by people on your team is a lot of how you add value to your company and earn your salary. What makes it easier to do is knowing how critical it is and what happens when you start to compromise. Incremental Conclusion There’s more to management that I’ll cover in the next installation in this series, but let’s review what I’ve covered here before moving on with your day. We defined management as “facilitating the work and professional maturity of those who report to you,” and showed how it could be considered in terms of Maslow’s hierarchy of needs. We then dove into the concept of context, all that stuff that exists around individual tasks that is critical to communicate to your implementers. Documentation, especially in terms of details, came next with some ideas about how to organize and communicate things on the page or screen. Finally (and fittingly), we covered the definition of done and how having one is critical to almost every aspect of delivery. Stay tuned for the next article, which will cover deadlines and protecting your team’s time, understanding the handoff points of your tasks, communicating doneness over time, promoting dialog through questions, and overall mentorship.

GitHub Action integration with Playwright enables seamless automated testing and deployment workflows for web applications. GitHub Actions, the platform’s automation tool, allows these tests to be triggered automatically upon code changes, ensuring rapid feedback and efficient bug detection. This integration empowers teams to build, test, and deploy with confidence, automating repetitive tasks and enhancing overall development productivity. By combining the versatility of Playwright with the automation capabilities of GitHub Actions, developers can streamline their workflows, delivering high-quality web applications with speed and precision. What Is Playwright? Microsoft Playwright is an open-source automation framework for end-to-end testing, browser automation, and web scraping. Developed by Microsoft, Playwright provides a unified API to automate interactions with web browsers like Microsoft Edge, Google Chrome, and Mozilla Firefox. It allows developers to write scripts in various programming languages, including Java, Python, JavaScript, and C#. Here are some key features of Playwright: Multi-Browser Support: Playwright supports multiple web browsers, including Firefox, Chrome, Safari, and Microsoft Edge. This allows developers and testers to run their tests on different browsers with a consistent API.Headless and Headful Modes: Playwright can run browsers in both headless mode (without a graphical interface) and headful mode (with a graphical interface), providing flexibility for different use cases.Cross-Browser Testing: Playwright allows you to write tests that run on multiple browsers and platforms, ensuring your web application works correctly across different platforms.Emulation of Mobile Devices and Touch Events: Playwright can emulate various mobile devices and simulate touch events, enabling you to test how your web application behaves on different mobile devices.Parallel Test Execution: Playwright supports parallel test execution, allowing you to run tests concurrently, reducing the overall test suite execution time.Capture Screenshots and Videos: Playwright can capture screenshots and record videos during test execution, helping you visualize the behavior of your application during tests.Intercept Network Requests: You can intercept and modify network requests and responses, which is useful for testing scenarios involving AJAX requests and APIs.Auto-Waiting for Elements: Playwright automatically waits for elements to be ready before performing actions, reducing the need for manual waits and making tests more reliable.Page and Browser Contexts: Playwright allows you to create multiple browser contexts and pages, enabling efficient management of browser instances and isolated environments for testing. What Is GitHub Actions? GitHub Actions is an automation platform offered by GitHub that streamlines software development workflows. It empowers users to automate a wide array of tasks within their development processes. By leveraging GitHub Actions, developers/qa engineers can craft customized workflows that are initiated by specific events such as code pushes, pull requests, or issue creation. These workflows can automate essential tasks like building applications, running tests, and deploying code. Essentially, GitHub Actions provides a seamless way to automate various aspects of the software development lifecycle directly from your GitHub repository. How GitHub Actions Effective in Automation Testing GitHub Actions is a powerful tool for automating various workflows, including QA automation testing. It allows you to automate your software development processes directly within your GitHub repository. Here are some ways GitHub Actions can be effective in QA automation testing: 1. Continuous Integration (CI) GitHub Actions can be used for continuous integration, where automated tests are triggered every time there is a new code commit or a pull request. This ensures that new code changes do not break existing functionality. Automated tests can include unit tests, integration tests, and end-to-end tests. 2. Diverse Test Environments GitHub Actions supports running workflows on different operating systems and environments. This is especially useful for QA testing, as it allows you to test your application on various platforms and configurations to ensure compatibility and identify platform-specific issues. 3. Parallel Test Execution GitHub Actions allows you to run tests in parallel, significantly reducing the time required for test execution. Parallel testing is essential for large test suites, as it helps in obtaining faster feedback on the code changes. 4. Custom Workflows You can create custom workflows tailored to your QA automation needs. For example, you can create workflows that run specific tests based on the files modified in a pull request. This targeted testing approach helps in validating specific changes and reduces the overall testing time. 5. Integration With Testing Frameworks GitHub Actions can seamlessly integrate with popular testing frameworks and tools. Whether you are using Selenium, Cypress, Playwright for web automation, Appium for mobile automation, or any other testing framework, you can configure GitHub Actions to run your tests using these tools In the next section, you will see how we can integrate GitHub Actions with Playwright to execute the test cases. Set Up CI/CD GitHub Actions to Run Playwright Tests Pre-Condition The user should have a GitHub account and already be logged in. Use Cases For automation purposes, we are taking two examples, one of UI and the other of API. Example 1 Below is an example of a UI test case where we log in to the site https://talent500.co/auth/signin. After a successful login, we log out from the application. JavaScript // @ts-check const { test, expect } = require("@playwright/test"); test.describe("UI Test Case with Playwright", () => { test("UI Test Case", async ({ page }) => { await page.goto("https://talent500.co/auth/signin"); await page.locator('[name="email"]').click(); await page.locator('[name="email"]').fill("[email protected]"); await page.locator('[name="password"]').fill("Test@123"); await page.locator('[type="submit"]').nth(1).click(); await page.locator('[alt="DropDown Button"]').click(); await page.locator('[data-id="nav-dropdown-logout"]').click(); }); }); Example 2 Below is an example of API testing, where we automate using the endpoint https://reqres.in/api for a GET request. Verify the following: GET request with Valid 200 ResponseGET request with InValid 404 ResponseVerification of user details JavaScript // @ts-check const { test, expect } = require("@playwright/test"); test.describe("API Testing with Playwright", () => { const baseurl = "https://reqres.in/api"; test("GET API Request with - Valid 200 Response", async ({ request }) => { const response = await request.get(`${baseurl}/users/2`); expect(response.status()).toBe(200); }); test("GET API Request with - Invalid 404 Response", async ({ request }) => { const response = await request.get(`${baseurl}/usres/invalid-data`); expect(response.status()).toBe(404); }); test("GET Request - Verify User Details", async ({ request }) => { const response = await request.get(`${baseurl}/users/2`); const responseBody = JSON.parse(await response.text()); expect(response.status()).toBe(200); expect(responseBody.data.id).toBe(2); expect(responseBody.data.first_name).toBe("Janet"); expect(responseBody.data.last_name).toBe("Weaver"); expect(responseBody.data.email).toBeTruthy(); }); }); Steps For Configuring GitHub Actions Step 1: Create a New Repository Create a repository. In this case, let’s name it “Playwright_GitHubAction.” Step 2: Install Playwright Install Playwright using the following command: Plain Text npm init playwright@latest Or Plain Text yarn create playwright Step 3: Create Workflow Define your workflow in the YAML file. Here’s an example of a GitHub Actions workflow that is used to run Playwright test cases. In this example, the workflow is triggered on every push and pull request. It sets up Node.js, installs project dependencies, and then runs npx playwright test to execute Playwright tests. Add the following .yml file under the path .github/workflows/e2e-playwright.yml in your project. Plain Text name: GitHub Action Playwright Tests on: push: branches: [main] pull_request: branches: [main] jobs: test: timeout-minutes: 60 runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-node@v3 with: node-version: 18 - name: Install dependencies run: npm ci - name: Install Playwright Browsers run: npx playwright install --with-deps - name: Run Playwright tests run: npx playwright test - uses: actions/upload-artifact@v3 if: always() with: name: playwright-report path: playwright-report/ retention-days: 10 Here’s a breakdown of what this workflow does: Trigger Conditions The workflow is triggered on push events to the main branch. Job Configuration Job name: e2e-testTimeout: 60 minutes (the job will terminate if it runs for more than 60 minutes)Operating system: ubuntu-latest Steps Check out the repository code using actions/[email protected] up Node.js version 18 using actions/[email protected] project dependencies using npm ci.Install Playwright browsers and their dependencies using npx playwright install --with-deps.Run Playwright tests using npx playwright test.Upload the test report directory (playwright-report/) as an artifact using actions/upload-artifact@v3. This step always executes (if: always()), and the artifact is retained for 10 days. Test results will be stored in the playwright-report/ directory. Below is the folder structure where you can see the .yml file and test cases under the tests folder to execute. Execute the Test Cases Commit your workflow file (e2e-playwright.yml) and your Playwright test files. Push the changes to your GitHub repository. GitHub Actions will automatically pick up the changes and run the defined workflow. As we push the code, the workflow starts to run automatically. Click on the above link to open the e2e-test. Click on e2e-test. In the screen below, you can see the code being checked out from GitHub, and the browsers start installing. Once all dependencies and browsers are installed, the test cases start executing. In the screenshot below, you can see all 12 test cases passed in three browsers (Firefox, Chrome, and WebKit). HTML Report Click on the playwright-report link from the Artifacts section. An HTML report is generated locally Click the link above to view the HTML report. Both API and UI test cases are passed. Wrapping Up GitHub Actions automate the testing process, ensuring every code change is thoroughly examined without manual intervention. Playwright’s ability to test across various browsers and platforms guarantees a comprehensive evaluation of your application’s functionality. By combining GitHub Actions and Playwright, developers can streamline workflows, ensure code quality, and ultimately deliver better user experiences.

By Kailash Pathak CORE

There has never been a greater demand for efficient learning management systems (LMS) in today's rapidly evolving digital world. To improve their learning environments, businesses, academic institutions, and training facilities are using cutting-edge technologies. Among these, artificial intelligence (AI) is a game-changer, improving learning management system development and producing more interesting and productive learning environments for contemporary students. Recognizing the Modern Learners Understanding the traits of contemporary learners is crucial before discussing how AI may improve LMS development. Today's students are tech-savvy, diverse, and frequently want individualized, on-demand education. They want easily available, interesting, and relevant knowledge and demand freedom in how and when they learn. Therefore, these expectations are not met by traditional LMS platforms that provide static, one-size-fits-all content. AI Affects the Creation of LMSs Through Adaptive Learning Adaptive learning is one of the most important ways AI influences LMS development. Traditional LMS systems frequently offer a one-size-fits-all approach to education, which can make learning more difficult for people with various requirements and backgrounds. To generate individualized learning paths, AI systems examine student interactions, performance information, and preferences. For example, an AI-powered learning management system can evaluate a student's strengths and shortcomings in real time. The system can customize course content, propose extra resources, or promote certain activities that fit the learner's particular needs by looking at previous assessments, interaction patterns, and task completion time. This degree of customization improves learning outcomes and knowledge retention in addition to increasing engagement. AI's Incorporation into LMS AI technologies have the potential to greatly enhance LMS platform functionality and increase their adaptability to the demands of contemporary learners. The following are some ways AI is influencing LMS development going forward: 1. Tailored Courses of Study AI's capacity to provide individualized learning experiences is among its greatest benefits. LMS software can examine a learner's performance statistics, preferences, and behavior using machine learning algorithms. Thanks to this analysis, the system may suggest customized learning paths that meet each user's needs. An eLearning app like Udemy, for example, can modify the curriculum to concentrate on difficult subjects if a student does well in some subjects but finds it difficult in others. This will guarantee a more successful learning experience. 2. Curation of Smart Content The sheer amount of content available to students today frequently overwhelms them. Intelligent content curation by AI-powered LMS can expedite this process. AI can identify the best resources by evaluating the quality and relevance of learning materials, considering the learner's objectives and current progress. This guarantees that students have access to pertinent, high-quality information while also increasing engagement. 3. Chatbots for Improved Engagement AI-powered chatbots are revolutionizing learners' interactions with LMS platforms. These virtual assistants can help students and teachers communicate, respond to questions, and offer immediate support. Chatbots' round-the-clock accessibility allows them to assist students in overcoming challenges in real time, which streamlines and expedites the learning process. Additionally, by collecting information on commonly requested topics, chatbots might help educational institutions pinpoint prevalent problems and enhance their course offerings. 4. Performance Monitoring With Predictive Analytics With AI-powered predictive analytics, learner performance may be better understood. At-risk learners can be identified, and prompt interventions can be implemented by LMS systems through the analysis of data trends. The LMS can alert teachers if a student routinely turns in work late or has below-average grades, for instance, who can thereafter act proactively to assist the student. In addition to improving student achievement, this data-driven strategy aids teachers in improving their pedagogical approaches. 5. Automating Tasks Related to Administration The learning process can frequently be hampered by administrative duties. By automating a number of administrative tasks, including grading, progress tracking, and enrollment procedures, AI can lessen this load. In addition to saving time, this lowers the possibility of human error, freeing up teachers to concentrate more on instructing and assisting their students. 6. Adaptive Learning and Gamification One effective strategy for raising student engagement is gamification. AI can assist in developing adaptive learning environments that employ gamification components to inspire students. Through the analysis of engagement and performance data, AI can modify quiz difficulty or provide incentives according to accomplishments. This enables students to take charge of their educational paths and makes learning more pleasurable. 7. Constant Evaluation and Enhancement AI allows platforms that construct learning management system development platforms to collect and evaluate user feedback continuously. The system can use surveys, quizzes, and interaction analytics to determine how successfully the learning materials relate to students. Continuous improvements are made possible by this feedback loop, guaranteeing that the information is useful and current. The LMS can change to meet the demands of contemporary learners as educational trends do. Challenges and Considerations Although there are many advantages to incorporating AI into LMS development, there are drawbacks as well. Organizations must make sure that student data is safeguarded and used appropriately; data privacy and security are critical. For educators to successfully integrate AI tools into their teaching techniques, they also require continual training and assistance. Furthermore, although AI can improve the educational process, it shouldn't take the role of human interaction in the classroom. To mentor, guide, and establish a personal connection with students, instructors continue to play a critical role. Conclusion A big step toward satisfying the demands of contemporary learners has been taken with the integration of AI into LMS development. Artificial intelligence (AI) is redefining education by providing tailored learning paths, intelligent content curation, and improved engagement through chatbots, as well as predictive analytics. Organizations and institutions will be better able to provide excellent, captivating learning experiences that equip students for success in a world that is always changing as they adopt these technologies. As the digital era progresses, AI will surely continue to influence LMS development, creating a setting where learning is not merely a duty but a fun and rewarding experience. A more knowledgeable and competent global community will result from embracing this potential, which will empower both educators and students.

In today's fast-paced business world, staying ahead often means finding ways to automate and streamline operations. Modern development platforms are at the forefront of this transformation, offering tools and technologies that simplify and accelerate the automation process. Whether it's through no-code tools that let you build applications without writing a single line of code or advanced AI systems that predict future trends, these platforms are making it easier for businesses to enhance efficiency and respond quickly to changing demands. By integrating various systems with APIs, adopting cloud-based solutions, and utilizing robotic process automation (RPA), companies can now automate repetitive tasks and improve their workflows more effectively. Tools like low-code platforms provide a customizable approach to development, while business process management (BPM) software helps optimize and refine processes. In this article, we'll explore how these modern development platforms are helping businesses streamline their automation efforts and achieve greater productivity. Join us as we dive into the world of automation and discover how these innovations are shaping the future of business operations. Leveraging No-Code Tools for Faster Deployment No code platforms are changing how businesses approach automation. These tools allow users to create applications without needing to write traditional code. By providing a user-friendly interface with drag-and-drop features, no code platforms enable faster deployment of automation solutions. This is especially valuable for small and medium-sized businesses that may not have extensive technical resources. By simplifying the development process, no-code tools facilitate rapid iteration and deployment, allowing businesses to adapt swiftly to changing needs. Integrating APIs for Seamless Data Flow APIs are essential for streamlining data flows between different systems. They enable various software applications to communicate with each other, automating data exchange and reducing manual input. For instance, integrating an API between a customer relationship management (CRM) system and an email marketing platform can automatically sync contact information and campaign data. This not only saves time, but also minimizes errors that can occur with manual data entry. Businesses like Shopify and Salesforce leverage APIs to connect their platforms with other services, enhancing overall efficiency and creating a more cohesive technology ecosystem. Utilizing Low-Code Platforms for Custom Solutions Low-code platforms offer a middle ground between traditional coding and no-code tools, allowing for customization with minimal coding. These platforms enable users to create bespoke applications tailored to their specific needs while still benefiting from a simplified development process. This approach is ideal for businesses with unique requirements that off-the-shelf solutions cannot fully address. By using low-code platforms, companies can accelerate development timelines and respond more effectively to changing business demands. Automating Repetitive Tasks With Robotic Process Automation (RPA) Robotic Process Automation (RPA) is a powerful technology for automating repetitive and rule-based tasks. RPA tools use software robots to perform tasks such as data entry, invoice processing, and customer service inquiries, freeing up human employees for more complex activities. For example, an RPA system can automate the process of extracting data from emails and entering it into a database, significantly reducing processing time and human error. Businesses in industries such as finance and healthcare have seen substantial improvements in efficiency and accuracy by implementing RPA solutions. This automation not only boosts productivity, but also enhances overall operational effectiveness. Enhancing Workflows With Workflow Automation Tools Workflow automation tools are designed to streamline business processes by automating repetitive steps and ensuring smooth transitions between tasks. These tools help businesses design and manage workflows, automate task assignments, and monitor progress. For example, tools like Asana and Monday.com allow teams to automate task notifications, approvals, and status updates. By automating these processes, businesses can improve collaboration and reduce the risk of missed deadlines or overlooked tasks. Workflow automation tools also provide valuable insights into process performance, enabling companies to identify bottlenecks and optimize their operations. This leads to more efficient workflows and better resource management. Adopting Cloud-Based Development Platforms Cloud-based development platforms are revolutionizing how businesses approach automation. These platforms offer scalability and flexibility by hosting applications and services on the cloud. Unlike traditional on-premises solutions, cloud-based platforms allow businesses to scale resources up or down based on demand, providing a cost-effective way to manage varying workloads. This cloud-based approach not only simplifies infrastructure management but also accelerates development cycles, enabling businesses to deploy new automation solutions quickly and efficiently. Implementing AI and Machine Learning for Predictive Automation Artificial Intelligence (AI) and Machine Learning (ML) are increasingly being integrated into automation strategies to enhance predictive capabilities. These technologies analyze large datasets to identify patterns and make predictions about future trends. For example, AI-driven tools can forecast customer behavior, optimize supply chain management, and personalize marketing strategies. Businesses such as Netflix and Amazon utilize AI to recommend products based on user preferences, significantly improving the customer experience. By incorporating AI and ML into their automation processes, companies can make more informed decisions, anticipate market changes, and optimize operations. This predictive capability helps businesses stay ahead of the competition and respond proactively to emerging trends. Streamlining Collaboration With Integrated Development Environments (IDEs) Integrated Development Environments (IDEs) play a crucial role in streamlining collaboration among development teams. Modern IDEs offer features that enhance productivity and facilitate seamless teamwork. These IDEs also support collaboration through features like real-time code sharing and collaborative debugging. By using integrated development environments, teams can reduce development time, improve code quality, and ensure that everyone is on the same page. This collaborative approach to development enhances the efficiency of automation projects and accelerates the delivery of new solutions. Optimizing Processes With Business Process Management (BPM) Software Business Process Management (BPM) software is essential for optimizing and automating business processes. BPM tools help organizations map, analyze, and improve their workflows to increase efficiency. For example, BPM software can automate approval workflows, streamline document management, and enhance process visibility. This optimization leads to more efficient operations, reduced costs, and improved compliance. By leveraging BPM software, businesses can continuously refine their processes, ensuring that automation solutions remain effective and aligned with their strategic goals. Ensuring Data Security and Compliance in Automated Systems Data security and compliance are critical considerations when implementing automation solutions. As businesses automate their processes, it is essential to safeguard sensitive information and adhere to regulatory requirements. Modern development platforms often include built-in security features such as encryption, access controls, and audit trails to protect data. For example, cloud providers offer comprehensive security tools and compliance certifications to help businesses meet industry standards. Additionally, businesses should implement robust data governance policies and conduct regular security audits to identify and address potential vulnerabilities. By prioritizing data security and compliance, companies can build trust with their customers and avoid costly breaches or regulatory fines. Conclusion Modern development platforms are significantly transforming how businesses streamline automation. From leveraging no-code tools and integrating APIs to adopting cloud-based solutions and implementing AI, companies are enhancing their operational efficiency and responsiveness. These platforms offer powerful capabilities for accelerating development, optimizing processes, and improving collaboration. However, as businesses embrace these technologies, they must also address critical considerations such as data security and compliance. By effectively utilizing these modern tools and practices, businesses can achieve greater automation efficiency, drive innovation, and maintain a competitive edge in an increasingly digital landscape.

Having spent years in the SaaS world, I've seen how AI is transforming team management. But let's be honest — it's not all smooth sailing. There are real challenges and ethical dilemmas we need to unpack. So, let’s cut through the noise and get into what it really means to bring AI into the mix for managing teams. The Double-Edged Sword of Efficiency First things first: AI is a powerhouse when it comes to efficiency. It can crunch numbers, analyze patterns, and make predictions faster than any human ever could. Sounds great, right? Well, yes and no. On one hand, AI can help us allocate resources more effectively, predict project timelines with scary accuracy, and even flag potential issues before they become full-blown problems. I remember when we first implemented an AI tool for workload balancing: it was like magic. Suddenly, we could see who was overworked, who had capacity, and how to distribute tasks more evenly. But here's the rub: this efficiency can sometimes come at a cost. I've seen team members start to feel like cogs in a machine, their work reduced to data points for an algorithm to analyze. It's a challenge to maintain the human element in team management when you've got an AI assistant crunching numbers and making recommendations. The Data Dilemma Now, let's talk about data. AI needs data to function, and in team management, that data is often deeply personal. Work habits, productivity metrics, and communication patterns — these are all grist for the AI mill. I once worked on a project where we used an AI tool to analyze team communication. The idea was to identify bottlenecks and improve collaboration. Sounds good in theory, right? But in practice, it felt a bit like Big Brother was watching. Team members started to feel uncomfortable, wondering if every message they sent was being scrutinized. This raises some serious ethical questions. How much data is too much? Where do we draw the line between helpful insights and invasion of privacy? It's a tightrope walk, and as team leaders, we need to be very careful about how we collect and use this data. The Black Box Problem Here's another challenge that keeps me up at night: the "black box" nature of many AI systems. Often, these tools make recommendations or decisions, but we can't always see the reasoning behind them. I remember a situation where our AI project management tool suggested reassigning a crucial task from one team member to another. On paper, it made sense: the second team member had more availability. But what the AI didn't know (and couldn't know) was that the first person had deep domain knowledge that was crucial for the task. This lack of transparency can be a real problem. As managers, we need to understand the "why" behind decisions to explain them to our team and to ensure they align with our broader goals and values. It's not enough to say, "The AI recommended it." We need to be able to critically evaluate these recommendations. The Human Touch Now, let's talk about something that's really close to my heart: the human element of team management. AI is great at analyzing data and spotting patterns, but it can't replace human intuition, empathy, and understanding. I've seen AI tools that claim to be able to measure team morale or predict which employees might be thinking of leaving. But in my experience, nothing beats actually talking to your team members, understanding their challenges, and building genuine relationships. There's a risk that over-reliance on AI could lead to a more impersonal management style. We need to be careful not to lose the human touch that's so crucial in building strong, cohesive teams. The Skill Gap Challenge Here's another challenge I've encountered: the skill gap. Implementing AI in team management isn't just a matter of flipping a switch. It requires new skills, both for managers and team members. One of my colleagues first started using AI tools for code review. It was great at catching potential bugs and style issues, but it also flagged a lot of false positives. The developers needed to learn how to interpret the AI's feedback, when to override it, and when to dig deeper. As managers, we need to ensure our teams have the training and support to work effectively with these AI tools. It's not just about using the tools: it's about understanding their limitations and knowing when human judgment needs to take precedence. Ethical Use and Bias Now, let's tackle a big one: ethical use and bias in AI. These systems are only as good as the data they're trained on and the algorithms they use. If that training data is biased, or if the algorithms have built-in biases, we could end up perpetuating or even amplifying unfair practices. Let me give you an example of an AI tool that was supposed to help with hiring decisions. It was quickly realized that it was showing a preference for candidates from certain universities —universities that were over-represented in its training data. They had to do a lot of work to identify and correct for these biases. As team leaders, we have an ethical responsibility to ensure that the AI tools we use are fair and unbiased. This means critically examining these tools, understanding their limitations, and being willing to override them when necessary. The Way Forward So, what do we do with all these challenges? Do we throw our hands up and abandon AI in team management? Absolutely not. The potential benefits are too great to ignore. But we need to move forward thoughtfully and ethically. Here's what I think we need to do: Stay informed: Keep up with the latest developments in AI ethics and best practices.Be transparent: Explain to your team how AI tools are being used and why.Maintain oversight: Don't blindly follow AI recommendations. Use them as input for decisions, not as the final word.Prioritize privacy: Be careful about what data you collect and how you use it.Foster human skills: Encourage skills like empathy, creativity, and critical thinking that AI can't replicate.Continuous evaluation: Regularly assess the impact of AI tools on your team and be willing to make changes. At the end of the day, AI is a tool — a powerful one, but still just a tool. It's up to us as leaders to use it wisely, ethically, and in a way that enhances rather than replaces human judgment. The future of team management will undoubtedly involve AI, but it's our job to ensure that the future is one where technology and humanity work hand in hand, creating better, more efficient, and more fulfilling work environments for everyone.

Project planning is one of the first steps involved in any form of project management. In this Agile era, whatever flavor of Agile it may be, programs and projects undergo a cadence for planning on the set-up of intentions for the next phase of delivering value to customers. In this generation of GenAI, there is an opportunity to catalyze productivity not just by reducing routine tasks through manual intervention, but also by providing key insights from analyzing the performance of previous delivery cycles and real-time progress tracking. Planning involves articulation of objectives, in-depth assessment of capacity, prioritization of features, identification of any eventual risks and issues, creation and communication of plans, and, subsequently, monitoring the progress. All of these steps take a lot of preparation, collaboration, and agility. Let’s consider a Program Increment (PI) Planning for further understanding of the challenges and how GenAI can be leveraged for different focus areas. Photo by Alvaro Reyes on Unsplash Key Focus Areas in PI Planning Defining Objectives For a successful execution of a PI, the objectives need to be clearly outlined. Teams participating in the planning need to define their own team objectives which align with the program objectives. Further, the vision for the PI must align with business goals and stakeholder expectations. A meaningful amount of time and focus need to be given to defining an unambiguous PI Objective. Assessing Capacity To make sure the work is appropriately distributed among teams and that there are higher chances of the teams delivering their objectives, understanding the team's capacity is crucial for planning. It is also important for the teams to be aware of their historical performance and current bandwidth. Prioritizing Features Next, the teams need to rank features and user stories based on value and effort. High-value features need to be prioritized for maximum impact. Communicating Plans Once the teams have an alignment on the objectives, it is necessary to have a good communication plan so that all stakeholders understand and are informed of what is expected of the PI. Monitoring Progress Tracking progress is essential to ensure that milestones are met, and anything that comes in the critical path is managed and dealt with. Ongoing assessment can help in adapting and making necessary adjustments to the delivery plan. Risk Mitigation For successful planning and delivery of projects, it is essential to identify the risks early. Awareness and management of risks can prevent project delays, ultimately saving costs. Leveraging GenAI to Addresses Key Challenges Photo by Growtika on Unsplash Using GenAI to Clarify and Align PI Objectives With Business Goals When teams and stakeholders don’t have a shared vision or a clear understanding of PI objectives, it’s like trying to row a boat without agreeing on the destination. Ambiguity creates confusion, leading to misaligned priorities, where each team may focus on different goals, wasting both time and resources. This lack of alignment often results in inefficient capacity utilization, with some teams overloaded and others underused, all because the objectives weren’t clearly defined from the start. To avoid this, PI objectives must be concise, easily understood, and communicated consistently. This helps everyone stay on the same page, ensuring that teams are directed toward the right priorities and goals are achieved more efficiently. GenAI can be a game-changer when it comes to defining PI objectives. Analyzing vast amounts of data in real time helps teams refine and clarify objectives with greater precision. This not only saves time but also ensures that the objectives are based on actionable insights. With its advanced analytics, GenAI can align PI objectives with broader business goals, giving leaders a clearer picture of what’s important and how to focus their efforts. This kind of data-driven clarity helps eliminate ambiguity and keeps teams aligned on the right priorities from the start. Optimizing Capacity Assessments With GenAI Predictive Analytics Overestimating or underestimating capacity can seriously impact delivery, throwing off timelines and causing frustration. If teams overestimate, they’ll struggle to meet deadlines, while underestimation might leave resources unused, slowing down progress. On top of that, changes in team composition — like new hires or people leaving — can shift a team’s ability to deliver, making earlier capacity assessments inaccurate. This is why it’s so important to continually reassess capacity, especially during PI planning, to ensure that teams are set up for success with realistic workloads and the right mix of skills. GenAI can make capacity assessments much more accurate by using predictive analytics to estimate team capacity based on historical data. It takes into account past performance, current workloads, and other variables to give a more reliable picture of what teams can handle. On top of that, GenAI can identify potential capacity bottlenecks before they become problems, suggesting adjustments or reallocations of resources to keep things running smoothly. With this kind of insight, teams can plan more effectively, avoiding overcommitment and making sure resources are used where they’re needed most. Enhancing Feature Prioritization With GenAI's Data-Driven Insights Prioritizing features can get messy, especially when stakeholders have conflicting priorities. What one group sees as essential, another might see as a nice-to-have, making it hard to rank features without stepping on toes. Add to that the pressure of limited time to properly evaluate each feature, and decisions can feel rushed or arbitrary. Without clear alignment on what truly matters, it’s easy for important features to slip through the cracks or for less critical ones to take up valuable development time. To get it right, teams need structured discussions and a shared understanding of the overall goals, ensuring that the most valuable features make the cut. GenAI can streamline the feature prioritization process by leveraging machine learning algorithms to assess both the value and effort associated with each feature. This means that instead of relying solely on subjective opinions, teams can make data-driven decisions that reflect the true impact of their choices. Additionally, GenAI offers scenario planning, allowing stakeholders to visualize the outcomes of different prioritization strategies. This helps everyone understand the trade-offs involved and creates a collaborative environment where informed decisions can be made. With GenAI, teams can focus on the features that will deliver the most value, ensuring that their efforts align with overall project goals. Transforming Communication With GenAI for Enhanced Stakeholder Engagement Miscommunication in a project can lead to teams working in different directions, wasting time and effort. When the message isn’t clear, people fill in the gaps with their own assumptions, and that’s where things go off track. It gets even trickier with diverse stakeholder groups — each with their own perspectives and priorities — who might interpret the plan differently. What seems clear to one team could mean something entirely different to another. That’s why it’s crucial to have a well-thought-out communication plan, one that delivers consistent, straightforward messages tailored to each group’s needs, to keep everyone on the same page. GenAI can transform the way teams share their plans by crafting communication materials that are both clear and engaging. It streamlines the information-sharing process, making it easier to convey complex ideas in a straightforward manner. By automating the generation of updates and reports, GenAI ensures that stakeholders receive timely and relevant information tailored to their needs. This targeted approach allows teams to effectively engage different audiences, from technical staff to senior leadership, supporting a culture of transparency and collaboration. Ultimately, this enhances everyone’s understanding of the project goals and keeps the entire organization aligned and focused on success. Harnessing GenAI for Real-Time Progress Tracking and Adaptive Planning When there’s a lack of visibility into progress, it’s like flying blind — you don’t know if teams are on track until it’s too late, and by then, delays are almost inevitable. Without regular check-ins or clear updates, issues can go unnoticed, piling up until they become big problems. On top of that, unanticipated challenges, like technical issues or shifting priorities, can throw the whole plan off course. These surprises often mean re-planning and adjusting resources mid-stream, which can slow things down even more. To avoid this, constant monitoring and clear communication about progress are essential to keep things moving smoothly and allow for quick adjustments when needed. GenAI tools are a powerful asset for monitoring progress, providing real-time tracking and predictive reporting that keeps teams informed every step of the way. With these insights, teams can quickly identify any issues that arise, allowing for prompt resolution before small problems escalate into bigger ones. Additionally, GenAI helps in adaptive planning by offering recommendations based on current progress and potential future outcomes. This means teams can pivot strategies as needed, ensuring that projects stay on track and aligned with their goals, ultimately leading to smoother execution and more successful outcomes. Leveraging GenAI for Smarter Risk Management in PI Planning Managing risks in an agile environment is tough because accurately identifying risks and estimating their scope means processing a lot of constantly changing data. Traditional predictive methods can struggle to keep up with the fast pace and frequent changes of agile projects. This makes it harder to spot new risks in time or to understand the full impact they might have. When these methods fail to adapt, entire program increments can get thrown off, leading to missed deadlines or unexpected challenges. To stay ahead, teams need flexible risk management approaches that can evolve as quickly as the project does, ensuring risks are caught and addressed before they derail progress. By using AI to run detailed scenario analyses, teams can explore a variety of "what-if" situations, helping them anticipate potential risks more accurately. This not only leads to more informed decision-making but also allows for refined scope estimations, as AI can quickly simulate different outcomes based on changing variables. With GenAI, teams can identify risks earlier and adjust their strategies in real time, making the entire planning process more resilient and adaptive to change. Conclusion Incorporating GenAI into PI Planning and execution isn't just about keeping up with trends — it's about revolutionizing how teams work. With its ability to provide real-time insights, optimize decision-making, and streamline communication, GenAI equips organizations to stay agile, aligned, and focused on delivering value. By embracing these tools, you can overcome common challenges like capacity miscalculations, unclear objectives, and miscommunication, ensuring smoother execution and stronger outcomes. Now is the time to act. Start exploring how GenAI can elevate your planning process, and drive your teams toward more efficient, data-driven success.

In today's fast-paced development environment, automating the deployment process is crucial for maintaining efficiency and reducing human error. GitHub Actions has emerged as a powerful tool for implementing continuous integration and continuous deployment (CI/CD) pipelines, particularly for web applications. This article explores how to leverage GitHub Actions to deploy a feedback portal seamlessly and efficiently. The Power of GitHub Actions GitHub Actions is more than just a CI/CD tool; it's a complete automation platform that allows developers to create custom workflows for building, testing, and deploying their applications. These workflows are triggered by specific events in your GitHub repository, such as pushes, pull requests, or scheduled tasks. Setting Up Your Deployment Workflow Creating the Workflow File The heart of your deployment process with GitHub Actions lies in the workflow file. This YAML file, typically named deploy.yml, should be placed in the .github/workflows/ directory of your repository. Here's an expanded example of a workflow file for deploying a feedback portal: This workflow does the following: Triggers on pushes of the main branchSets up a Node.js environment and caches dependencies for faster buildsInstalls dependencies, runs tests, and builds the projectIf all previous steps succeed and the event is pushed to main, it deploys a feedback portal App on to given server. YAML name: Deploy Feedback Portal on: push: branches: - main jobs: build_and_test: runs-on: [ubuntu-latest, self-hosted] steps: - name: Checkout code uses: actions/checkout@v4 - name: Set up Node.js uses: actions/setup-node@v3 with: node-version: '16' - name: Cache dependencies uses: actions/cache@v3 with: path: ~/.npm key: ${{ runner.os }-node-${{ hashFiles('**/package-lock.json') } - name: Install dependencies run: npm ci - name: Run tests run: npm test - name: Build project run: npm run build deploy: needs: build_and_test runs-on: ubuntu-latest if: github.ref == 'refs/heads/main' steps: - name: Checkout code uses: actions/checkout@v4 - name: Deploy to On-Prem Server run: | # Using secrets for username and password (or SSH key) scp -r ./dist/ ${{ secrets.SERVER_USER }@your-server:/path/to/your/application ssh ${{ secrets.SERVER_USER }@your-server "cd /path/to/your/application && ./restart-service.sh" # If you are using an SSH key env: SSH_PRIVATE_KEY: ${{ secrets.ONPREM_SERVER_SSH_KEY } run: | echo "${SSH_PRIVATE_KEY}" > keyfile chmod 600 keyfile scp -i keyfile -r ./dist/ ${{ secrets.SERVER_USER }@your-server:/path/to/your/application ssh -i keyfile ${{ secrets.SERVER_USER }@your-server "cd /path/to/your/application && ./restart-service.sh" Explanation 1. Secrets in GitHub Actions ${{ secrets.SERVER_USER }: This will be replaced with the actual value of the user’s name that you stored as a secret in the GitHub repository.${{ secrets.SERVER_SSH_KEY }: This is where the private SSH key is securely accessed for deployment. 2. SSH Key Authentication If you are using SSH keys for authentication, you can add the SSH private key as a secret (e.g., SERVER_SSH_KEY). The key is temporarily saved in the workflow as a file (keyfile), and scp and ssh commands use it to securely transfer files and restart the service. 3. Environment Variables The env key is used to pass secrets like the SSH private key as environment variables in the workflow. 4. Triggering the Workflow The workflow is triggered whenever code is pushed to the main branch. 5. Jobs build_and_test: This job installs dependencies, runs tests, and builds the application.deploy: This job deploys the application to your on-prem server after the build is successful. 6. Workflow Steps actions/checkout@v4: Checks out the repository codeactions/setup-node@v3: Sets up Node.js version 16 for the environmentactions/cache@v3: Caches npm dependencies to speed up future builds; It uses the package-lock.json file to generate a unique cache key. If the lock file changes, a new cache will be created, otherwise, it will restore from the cached dependencies.npm ci: Installs the dependencies specified in the package-lock.json file, ensuring a clean and reproducible environmentnpm test: Runs tests to ensure the application works as expectednpm run build: Builds the application, typically creating production-ready assets in a dist folderDeploy to On-Prem Server: Uses scp to transfer the built files to your on-prem server and ssh to execute a script that restarts the application. Environment-Specific Deployments For more sophisticated deployment strategies, you can use GitHub Environments to manage different deployment targets: YAML jobs: deploy_to_staging: runs-on: ubuntu-latest environment: staging steps: # Deployment steps for staging YAML deploy_to_production: needs: deploy_to_staging runs-on: ubuntu-latest environment: production steps: # Deployment steps for production This setup allows you to define specific protection rules and secrets for each environment, ensuring a controlled and secure deployment process. Configure Your On-Prem Server Shell #!/bin/bash cd /path/to/your/application # Stop the currently running service sudo systemctl stop feedback-portal # Deploy new changes (clear the old build and move the new files) sudo rm -rf /var/www/feedback-portal/* sudo cp -r dist/* /var/www/feedback-portal/ # Restart the service sudo systemctl start feedback-portal Artifact Management For multi-stage deployments or when you need to pass build outputs between jobs, use artifacts: YAML - name: Upload artifact uses: actions/upload-artifact@v3 with: name: dist path: dist In a later job: YAML - name: Download artifact uses: actions/download-artifact@v3 with: name: dist This allows you to build once and deploy to multiple environments without rebuilding. Repository Structure A typical structure for your feedback portal repository might look like this: Perl feedback-portal/ ├── .github/ │ └── workflows/ │ └── deploy.yml ├── config/ │ ├── config.json # Configuration file │ └── other-config-files.json ├── src/ # Application source code │ ├── components/ # Frontend components │ ├── services/ # Backend services │ └── index.js # Entry point for your application ├── tests/ # Test files │ └── example.test.js ├── package.json # npm package file ├── package-lock.json # npm lock file └── README.md # Project documentation Key Components of the Repository .github/workflows/ This directory contains your GitHub Actions workflows. Here, you have deploy-feedback-portal.yml to deploy your application and update-portal-config.yml for managing configuration updates. config/ This directory should hold all configuration files for your portal, such as config.json, which contains settings for the application (e.g., database connections, API keys). src/ This is where your application’s source code will live. Organize your code into subdirectories for better maintainability. For instance, you might have a components/ directory for front-end components and a services/ directory for backend API services. tests/ A directory for your test files, ensuring that you can run tests to validate the functionality of your code. package.json and package-lock.json These files are used by npm to manage dependencies for your project. The package.json file defines your project and its dependencies, while the package-lock.json ensures that the same versions of dependencies are installed every time. By organizing your feedback portal code in a structured manner within your GitHub Enterprise repository, you facilitate easier collaboration, management, and deployment. With the workflow and server configuration in place, you now have a fully automated CI/CD pipeline that builds, tests, and deploys your feedback submission portal to an on-prem server. This setup leverages GitHub Enterprise and GitHub Actions, ensuring that your deployments are consistent, secure, and reliable, all while staying within your internal infrastructure. By customizing this workflow, you can deploy other types of applications, integrate further testing steps, or enhance security as needed. Conclusion GitHub Actions offers a robust and flexible platform for automating web portal deployments. By leveraging its features — from basic workflows to advanced configurations like environment-specific deployments and matrix builds — developers can create efficient, secure, and scalable deployment pipelines. As you implement these strategies, remember that the key to successful automation is continuous refinement. Regularly review and optimize your workflows, stay updated with the latest GitHub Actions features, and always prioritize security in your deployment processes. By mastering GitHub Actions for web portal deployment, you're not just automating a task — you're adopting a philosophy of continuous improvement and efficiency that can transform your development workflow and give your team a significant advantage in delivering high-quality web applications.

TL; DR: Unfinished Action Items: How to Make Retrospectives Useful If your team consistently creates action items during Retrospectives but rarely completes them, you’re not alone. Unfinished action items are a major productivity killer and lead to stalled progress. This article highlights five actionable practices to ensure Retrospective tasks get done, including limiting action items in progress, assigning clear ownership, and adding a reviewing progress in every Retrospective. The key to real improvement isn’t in creating long lists — it’s in following through. By treating Retrospective action items with the same importance as other Sprint tasks, your team can finally break the cycle of unfinished improvements and see real, beneficial change, individually and at the team level. The Problem With Unfinished Action Items How often have you left a Retrospective feeling like you’ve cracked the code, only to realize two Sprints later that nothing has changed? We’ve all been there. Teams are great at creating action items, but things tend to fall apart when it comes to following through. It’s not enough to just make lists of improvements — we need actually to implement them. One of Scrum’s first principles is continuous improvement, derived from Lean’s Kaizen philosophy. Kaizen focuses on small, incremental changes that compound, driving long-term progress. Scrum incorporates this through Retrospectives, where teams identify areas for improvement after each Sprint. However, Kaizen only works when improvements are implemented. Unfinished action items break the cycle, leaving issues unresolved and stalling growth. Unfinished action items are one of Scrum teams’ biggest productivity and improvement killers. Without follow-up, improvements remain theoretical. The accumulation of unfinished items leads to repeat issues and disengagement from the Retrospective process. The True Purpose of a Retrospective: Why Action Items Are Still Essential Many Scrum teams recognize the value of Retrospectives beyond just generating action items. They focus, for example, on team alignment or improving psychological safety, which are all vital elements of an effective team. However, without agreeing on improvements, these activities may prove superficial: Team alignment ensures everyone is working cohesively toward the same goals. But alignment without concrete actions won’t result in real, tangible improvements.Psychological safety promotes trust, but discussions without action can lead to complacency.Process improvement discussions are valuable, but without actionable steps, those improvements will remain theoretical.Conflict resolution helps smooth collaboration but should be followed by actions that prevent future issues.Continuous learning drives reflection but only becomes impactful when applied. So, some teams believe these benefits alone are enough to call the Retrospective a success, often neglecting the crucial step of creating and following through on actionable improvements. While these five elements are critical, they are not enough on their own. Action items are the glue that binds these insights together and translates them into real, continuous improvement. Teams must avoid the pitfall of thinking that a Retrospective is complete without tangible, actionable steps. How to Turn Action Items Into Completed Improvements By following a few key strategies, you can double or even triple the effectiveness of your Retrospectives. It’s not just about identifying areas for improvement but ensuring those are followed through. The following steps will help your team turn Retrospective action items into actual, impactful results: Limit the number of action items: Focus on 1–3 high-priority items per Retrospective. Too many action items overwhelm the team and lead to incomplete follow-through.Assign clear ownership and dates: Each action item needs a specific owner and a “delivery date.” Without these, tasks fall through the cracks. Ensure items are concrete and measurable, such as “Sarah will set up a weekly sync with the marketing team by Friday.” (Think of “Directly Responsible Individuals.”) Review previous action items at every Retrospective: Start every Retrospective by reviewing the status of the last Sprint’s action items. This holds the team accountable and helps identify why certain items weren’t completed and where support from the team is needed. (Inspection and adaptation work here, too.)Track action items publicly: Use a public board to track progress. Visibility drives accountability and ensures that action items don’t get forgotten.Make action items part of Sprint Planning: Incorporate action items into Sprint Planning, ensuring they are treated with the same attention as other Sprint tasks, preventing them from being sidelined. Food for Thought on Action Items Here are some additional insights to help ensure that team members complete action items, leading to continuous improvement: SMART goals for action items: Use SMART goals — Specific, Measurable, Achievable, Relevant, Time-bound — when defining Retrospective action items. Instead of saying “improve communication,” try “Set up a weekly check-in with the marketing team by Friday.” This ensures clarity and accountability. (Learn more about SMART and INVEST.)Continuous monitoring during the Sprint: Don’t wait until the next Retrospective to check in on action items. Dedicate, for example, a portion of your Daily Scrum sessions to quickly review progress on action items if needed, ensuring they stay top-of-mind throughout the Sprint.Balance between process and product improvements: Ensure a balance between process improvements (like communication and collaboration) and product improvements (such as code quality and technical practices). Focusing too much on one over the other can lead to lopsided progress.Avoid picking only low-hanging fruits: Real change results from tackling big issues that may require more than a Sprint or two to complete. Therefore, to reach your team’s full potential, avoid focusing solely on small improvements to keep your action item list short and tidy.Celebrate wins: When action items are completed and result in improvements, recognize and celebrate these wins. This acknowledgment reinforces the value of the Retrospective and motivates the team to take future action items seriously.Be mindful of organizational culture: Company culture has a significant impact on how action items are handled. If the organizational structure is too hierarchical or top-down, teams might feel powerless to implement change. Building a culture of autonomy and support for Scrum teams is, therefore, essential. Conclusion: The Key to Continuous Improvement Is Follow-Through Unfinished action items undermine continuous improvement. While identifying areas for growth in a Retrospective is important, implementation is where progress happens. The Kaizen principle teaches us that meaningful change comes from small, consistent improvements, but only when the team ensures those improvements are realized. To break the cycle of unfinished action items, focus on completing fewer, higher-impact actions. By following the five steps outlined here, your team can close the gap between planning and execution, and transform Retrospectives into a tool for real, measurable change. Continuous improvement isn’t just a principle — it’s a process, and your team holds the key to making it work.

By Stefan Wolpers CORE