key: cord-0676601-ww6g0n6l authors: Okpara, Laura; Werner, Colin; Murray, Adam; Damian, Daniela title: A Case Study of Building Shared Understanding of Non-Functional Requirements in a Remote Software Organization date: 2022-05-18 journal: nan DOI: nan sha: 08080ae56ffb6b48b37c20285b0bd181f7255596 doc_id: 676601 cord_uid: ww6g0n6l Building a shared understanding of non-functional requirements (NFRs) is a known but understudied challenge in requirements engineering, especially in organizations that adopt continuous software engineering (CSE) practices. During the peak of the COVID-19 pandemic, many CSE organizations complied with working remotely due to the imposed health restrictions; some continued to work remotely while implementing business processes to facilitate team communication and productivity. In remote CSE organizations, managing NFRs becomes more challenging due to the limitations to team communication coupled with the incentive to deliver products quickly. While previous research has identified the factors that lead to a lack of shared understanding of NFRs in CSE, we still have a significant gap in understanding how CSE organizations, particularly in remote work, build a shared understanding of NFRs in their software development. We conduct a three-month ethnography-informed case study of a remote CSE organization. Through thematic analysis of our qualitative data from interviews and observations, we identify a number of practices in developing a shared understanding of NFRs. The collaborative workspace the organization uses for remote interaction is Gather, which simulates physical workspaces, and which our findings suggest allows for informal communications instrumental for building shared understanding. As actionable insights, we discuss our findings in light of proactive practices that represent opportunities for software organizations to invest in building a shared understanding of NFRs in their development. Many software organizations are adopting continuous software engineering (CSE) practices, such as continuous integration and delivery [29] , to support the release of working software through automation and shorter cycle times between releases [16] . CSE has implications for requirements engineering practices as it combines activities from agile methodologies that emphasize individuals and interactions, working software, customer collaboration, and response to rapid changes [17] . However, previous research has identified the lack of shared understanding as a significant challenge in managing nonfunctional requirements (NFRs) in CSE [49] . Shared understanding of NFRs is essential due to the complex, crosscutting nature of NFRs [2] and the importance of NFRs to the success of software projects. For example, consider NFRs such as security [47] [43] ; e.g. if data encryption is poorly implemented, a data breach can expose user information. Werner et al. describe the factors that contribute to the lack of shared understanding of NFRs, such as the fast pace of change and lack of domain knowledge [48] . However, there is still a lack of empirical evidence regarding how a CSE organization builds and manages a shared understanding of NFRs. Working remotely creates further challenges in managing NFRs, along with their understanding, due to geographic distance, differences in context, and heavy reliance on communication technologies [19] . There are barriers to building a shared understanding, as conveying information through non-verbal communication is difficult in remote environments [32] . During the COVID-19 pandemic, there was a global shift from in-person activities to working remotely [5] . Many organizations had to adapt processes and systems to support team productivity, through virtual communication tools, social engagements, and peer support [39] . With the significant shift of software organizations working remotely, the motivation for this study stems from the need to explore how remote CSE software organizations build a shared understanding of NFRs to potentially minimize rework [48] and other costs that may result from a lack of shared understanding of NFRs. The primary goal of this study is to investigate how remote CSE software organizations build and maintain a shared understanding of NFRs. The secondary goal of this study is to provide additional insight into the limitations or challenges to a shared understanding of NFRs in CSE. Two main research questions guided our study: RQ1: How does a remote software organization that adopts CSE practices reach a shared understanding of NFRs? RQ2: What are the limitations to the shared understanding of NFRs in a remote software organization that adopts CSE practices? Our work brings two significant contributions to the field of requirements engineering: 1) We add to the growing knowledge of shared understanding of NFRs in requirements engineering by explicitly describing practices for building a shared understanding of NFRs in remote organizations that adopt CSE practices. 2) We discuss practical ways for remote CSE organizations to proactively build a shared understanding of NFRs. Previous empirical studies suggest that managing NFRs can be challenging to software organizations for varying reasons, such as sparse documentation of NFRs or when documentation may be imprecise [2] , along with the lack of consensus on how to sufficiently document and communicate NFRs [21] . NFRs are important to the success of software projects; however, research suggests that there is still some conflict in how software organizations manage NFRs [36] . NFRs are often neglected in requirements engineering due to the difficulties in eliciting NFRs, as NFRs have cross-cutting concerns with FRs [47] . Research suggests that NFRs have a representation problem and when NFRs are not described or represented properly, they can be misinterpreted as FRs [21] . NFRs such as security and privacy are important to software projects, but often neglected [47] and may be specified too late resulting in system vulnerabilities [43] . The main challenge is to understand the complex nature of NFRs and to create practices to manage the shared understanding of NFRs [37] . This is the gap that we intend to fill in this study by exploring practices to build a shared understanding of NFRs. CSE increases the need for an effective flow between customer needs and the rapid delivery of a product or service [16] through the automated release of working software in short release cycles. While this concept is already established through the agile manifesto [17] , CSE is a more holistic approach as it includes activities to extend these practices such as continuous verification, improvement, and innovation [16] . Previous research suggests that shared understanding among people exists in two forms: implicit and explicit [22] . There is implicit shared understanding when people have a mutual understanding of unspecified facts or assumptions; whereas there is explicit shared understanding when people have a mutual understanding of specifications such as documents. Shared understanding is beneficial to CSE projects as it can promote successful collaboration [10] ; when shared understanding exists, a team member is able to predict other's behaviours, there is an increase in team motivation and less conflict or mistrust among the team. Continuous integration, as CSE emphasizes, provides quick feedback to support the frequent release of working software, ensuring that potentially failure-inducing problems are identified and resolved as quickly as possible [16] . We bring further evidence from this study toward how shared understanding is built in CSE. Werner et al. studied shared understanding of NFRs in CSE within three organizations [48] . They traced the effects of the lack of shared understanding in the form of rework in software projects, and they found that managing NFRs in CSE comes at a cost, such as fast pace of change, inadequate communication, and a lack of domain knowledge. They recommend practices for building a shared understanding of NFRs: communication and shared standards. Similarly, previous research reports the difficulties with automating NFRs and the problem of prioritizing functional requirements (FR) over NFRs [49] . However, these studies do not address how a CSE organization builds a shared understanding of NFRs. Shared understanding cuts across several fields, disciplines, and contexts, such as education [41] , medical science [24] , design science [7] , or engineering [22] . Several definitions of shared understanding exist in literature, one study describes shared understanding as "the ability of multiple agents to coordinate their behaviours with respect to each other to support the realization of common goals or objectives" [6] . Hinds conceptualizes shared understanding as a collective way of organizing relevant knowledge and a means for team members to anticipate and predict the behaviors of their peers or group [26] . These definitions focus on people and how they communicate to reach a common goal or objective. Research evidence suggests that in software organizations, informal communication is essential for understanding and communicating about stakeholder values and needs [4] . Informal communication is interactive and includes unplanned interactions that occur in the midst of daily activities [46] [13] . Kraut et al. discuss informal communication as based on the degree of preplanning, therefore, informal communication can be scheduled, intended, opportunistic, or spontaneous [33] . Research evidence in requirements engineering suggests that inadequate communication contributes to a lack of shared understanding [48] . Furthermore, daily informal communication allows team members to develop working relationships and encourages a better flow of information [1] . Having a virtual shared space in remote software organizations is important for collaboration on software projects [3] . In this study, we bring empirical evidence on how a remote software organization manages communication of NFRs in the absence of traditional in-person informal communication. Our case study used ethnography-informed methods to study how a remote software organization, Alpha (fictitious name to protect confidentiality), attempts shared understanding in their product development. We first outline the study setting in terms of the organization studied, its processes and working environment. We then follow with a description of the data collection and analysis methods. We identified a remote organization, Alpha, that practices CSE. Alpha is a Canadian based software organization that develops loyalty, rewards, and referral programs for businesses, as their primary revenue source. Alpha has operated for 9 years with 29 global employees. Alpha is primarily client-focused, with most of its products having heavy visual components, including third-party platforms and storing client information. Alpha prioritizes NFRs such as performance, usability, security, and maintainability to meet their stakeholders' needs. The software engineering team at Alpha includes project leads (manager or developer), solutions architects, front-end and back-end software developers, user experience (UI/UX) designers/developers, and software integration engineers. During the COVID-19 pandemic, Alpha shifted to remote work to comply with the health restrictions imposed on businesses within the region and country and, having adapted its business operations and approach, stayed fully remote for over two years. Alpha used Gather, a video chat platform designed to make virtual interactions more human. Alpha's communication methods and tools. Similar to many other organizations during the COVID-19 pandemic, Alpha had to pivot to work remotely. Alpha initially used video conferencing tools such as Zoom; however, it soon discovered that it did not create connectedness within the software team, e.g. "we started out like that when the pandemic first hit, we all went remote. Initially, it was so disconnected. No one felt connected to anyone else. It was so difficult to engage people in random conversation" (Manager). Alpha then switched to using Gather [18] , a virtual interaction tool that creates a work environment similar to a physical workspace, including desk spaces, meeting rooms, and avatars that represent the team members. Gather is fully customizable and allows Alpha to interact virtually as much as they would do in a physical space: whenever an avatar (team member) "walk" near another team member's avatar, a video call would be initiated in an easy and ubiquitous way, to simulate informal communication available in physical co-location, e.g "Gather has made it possible for us as a remote team to have informal conversations. You literally just walk your little character up to someone else's little character, and you're talking to them." (Manager) During meetings, Alpha's employees "walk" their avatar to the virtual meeting room in Gather and can choose to sit at the table. A group video call on Gather would begin as soon as they are near each other. Alpha's employees can also create private spaces (bubbles) with each other while in group meetings for one-on-one conversations when necessary, creating the feeling of being in the same space with each other. Alpha uses Gather to host social events, such as Christmas parties, encouraging team members to interact with each other beyond their daily work. Alpha also uses Slack [44] to provide and receive frequent updates relevant to daily activities, and web documentation tools to communicate and document requirements such as Coda [9] to review backlogs, view the status of previous or ongoing tasks, and update tasks seamlessly throughout the life cycle of projects. Alpha's software and requirements engineering processes. Alpha adopted CSE practices such as frequent feedback loops, continuous verification, and continuous testing based on stakeholder needs. Empirical evidence suggests an organization that adopts CSE may focus on certain CSE practices such as continuous integration for several reasons to suit their business and stakeholder needs [14] . The software engineering team at Alpha uses continuous delivery to frequently deliver working software in short cycles, welcoming changing requirements to meet the stakeholders' needs. In addition, Alpha implements a people-driven, autonomous approach incorporating tribes and guilds [45] . A tribe describes a group of people who work on similar feature areas of the software products; they coordinate and align themselves through the tribe leader, usually a senior member of the tribe. Tribe members have the necessary software engineering skills to come together and engineer working software features from "end-to-end." A guild describes a group of people with similar interests who have similar roles or perform similar tasks. Guild members come together to share knowledge, support each other and share processes to create a community that fosters learning and growth in specific areas. Before starting a new project, a project kick-off meeting first occurs that includes stakeholders, such as success representatives, customers, or upper-level management. The meeting defines some of the high-level software requirements, including NFRs, and the project scope through user/data flows, product designs, and demos to understand the software product to be built. The project evolves with the delivery of working usable software in short cycles by continuously verifying project requirements with stakeholders throughout the software development process "to ensure that the right thing has been built and it has been built right" (Developer). The project lead initiates frequent feedback cycles such as weekly or biweekly meetings with the stakeholders involved in the project, the feedback from these meetings can be change requests, new requirements or software bugs discovered. The rapid feedback cycles continue and the project continues to evolve until all requirement requests have been implemented or all of the stakeholders are satisfied with the product built. At Alpha, software developers have some freedom and flexibility to implement the software requirements, especially the NFRs. However, an engineer must collaborate with the project lead to remove ambiguity and to create an architecture allowing all components to work together. For three months, one of the authors was embedded at Alpha to learn about the products, processes, and business. Through many informal conversations with the software engineering team, an intention was to understand how the team shared understanding, knowledge and how they communicate and document requirements. Alpha onboarded the on-site researcher by providing a work email, providing a dedicated computer, and granting access (through invitation) to their collaboration tools and platforms such as Gather, Slack, Coda, Google Drive [8] and GitHub [20] . Our data collection techniques were through observations and interviews. Participant Observation: The on-site researcher observed the participants and their interactions during regular work activities and meetings with the software team and stakeholders, including customers and upper-level management. By engaging in informal conversations with employees, the researcher learned about their roles and experience and developed a How would you describe the process of reaching a shared/mutual understanding of non-functional requirements for any project? Q6 When can you say that everyone on your team understands the non-functional requirements sufficiently to produce substantial work? Q7 How would you describe the factors that hinder or limit your understanding of non-functional requirements when working with other people? working relationship with the team to help design the interview questions and interpretation of interview responses. Interviews: Eleven semi-structured interviews were conducted via Zoom during the third month of the study. Each interview time varied between 30 and 45 minutes and was fully transcribed. The interviewees had various roles with varying years of experience, from a couple of months to fifteen years of experience. To protect the anonymity of our participants, we label developer/designer roles and team leads as developers and other remaining management roles as managers, as seen in Table I . Following a grounded theory approach, we iteratively developed the interview questions based on emerging patterns that helped us to establish an area of focus or interest [27] . The interviews focused on highlighting how shared understanding of NFRs is established and what challenges may limit the shared understanding of NFRs. We used open-ended questions to allow participants to describe their experiences. We sought each participant's view on shared understanding and how Alpha may reach a shared understanding of NFRs. The interviews were audio-recorded with consent. A sample of the interview questions can be found in Table II . Data analysis involved fully transcribing audio recordings from interview sessions and creating insights using the back-ground information obtained through observations. The observation data collected was analyzed by noting patterns and data relevant to our study. We used this data to describe our study setting and design the research questions for the interviews. We also used the data from our observations to interpret the interview findings by understanding and describing Alpha's context and discussing our study's implications. We used the open and axial coding methods from grounded theory [27] to identify themes [31] across several codes from the interviews, while creating memos to describe the relationships and patterns observed in the data and any additional questions that may be explored. We also identified the triggers that led Alpha to build a shared understanding of NFRs, as suggested by Werner et al. [48] , further discussed in Section V. Two independent coders were involved in the thematic coding process [31] . Agreement sessions were used to consolidate coding strategies, and to establish the reliability of the codes. We calculated the inter-rater reliability agreement until we reached substantial inter-rater reliability >0.60, using the Cohen Kappa's coefficient for measuring observer agreement for categorical data [34] . First, to understand how the software team views NFRs, we asked participants to tell us which NFRs were vital to the success of the projects that they work on. In our data analysis, we recognized three major NFRs that were mentioned repeatedly: usability, performance and maintainability. We also recognized a pattern where the NFRs mentioned during the interview sessions differed depending on the role and level of experience of the participant. Front-end developers and designers mainly describe usability and performance when referring to NFRs e.g. "Well, usually the biggest NFRs that we get are everything to do with how it looks. When you're dealing with visual specs, the most important thing is usually how it behaves in different environments" (Developer). Similarly, engineering leads and managers made reference to performance and understandability e.g. "But you could definitely consider there to be NFRs for our public APIs. And the things that you want to consider in those cases are, does the API make sense? Is it familiar for other developers? Is it something that they could easily discover?" (Manager). In another instance, a manager mentions security as an important NFR for their clients. e.g. "They want to know that the data that they are providing us ... is secure, it's deleted when they need it to be deleted, and that the transmission is secure as well, that it's encrypted, and that there is no way to intercept the data as they're sending it to us or retrieving it" (Manager). We then asked participants how they reach an understanding of NFRs for any project they have worked on. From our data analysis, we identified five practices (themes from our data) at Alpha, outlined in Table III , and described below. In addition to the codes from which we developed these themes, Table III also provides information as to whether our data indicates that 2) Deepening the understanding of NFRs through experience: Four of our participants expressed to us that they deepen their understanding of NFRs over time through the projects that they work on within Alpha. These NFRs are sometimes not explicitly defined but incorporated into already existing processes and the developer learns how to implement them through those processes over a period of time. e.g "There's just a process that isn't formally presented, it's just picked up over time through training. I think that's the majority of NFRs are, for me anyways have been picked up that way" (Developer). Developers told us that a helpful way to deepen their understanding of NFRs is through learning how NFRs are handled in previous similar projects. e.g. "I think the biggest tool that has helped me learn NFRs has really just been reviewing previous work, reviewing previous specs, reviewing previous integrations, things like that, because it's the best way to get a sense of the expected code quality and expected way of doing things" (Developer). A developer describes how Alpha keeps people connected even while working remotely and how that helps with deepening the understanding of NFRs "I did mention earlier that Alpha is remote first but I do find that they do a good job of keeping people connected. And I think Gather town has really helped with that, it's just a place where you can feel like you're next to the people that you're working with. And they're, a few button clicks away from a call to talk about things and screenshare" (Developer). However, we observed that some of our participants expressed some difficulties in understanding NFRs due to a lack of experience. e.g "I still think I'm learning what the requirements are for spec writing, because it's just it's a nuanced aspect of the requirements .... So it's something that I'm still learning, but definitely have a better understanding of than when I first started." (Developer). Nevertheless, a software developer describes learning Alpha's values as an important factor to gaining a shared understanding of NFRs e.g. "I guess the tricky thing is that a lot of getting shared understanding, I think is almost kind of unwritten, it's like, you have to get a sense for how your organization values those NFRs to be able to kind of work with others around you" (Developer). 3) Wireframing interface designs: We observed that another way Alpha reaches a shared understanding of NFRs was through wireframing. Our participants express that they mostly used Figma, sketches or minimal designs to describe some of the NFRs during project meetings or informal conversations. e.g. "And that usually involves using something like figma, or fig jam to quickly visualize what we're talking about. So really basic forms, like shapes, and just text, and blocks of lines that connect different screens" (Developer). To mitigate the challenges that could occur when working with visual components remotely, developers describe the use of screenshare on Gather, as a way that makes it easier to reach a shared understanding of NFRs. e.g "A kind of advantage of Gather is that you get to share your screen and [person] likes to write diagrams and stuff like that or just mock-up code on the screen, which definitely makes things easier to understand" (Developer). A manager further describes the effectiveness of wireframing interface designs by stating "I think that's where things like 'shaping', wire-frames, starting to try to think through that user experience really helps. Design drawings, I find are really helpful. Early mock-ups help people because I find that a lot of the team does well with actually experiencing something. They quickly start to see ... this does the thing, but it's totally unusable for other reasons" (Manager). For NFRs such as usability, visualizing what needs to be built and receiving feedback on those designs from other developers and clients ensures that there is a shared understanding of those NFRs. e.g. "If we take the NFRs that are typically involved in something like visual design, in terms of user experience, obviously we have our designer who will design something, but we do try to obtain as much feedback on that design as possible. If possible, we actually like to communicate that or publicize it with the client, if there is something that's clientspecific" (Manager). Developers express that they sometimes gain more understanding about NFRs through discussions during regularly scheduled meetings on Gather, such as bi-weekly guild meetings. e.g " It's really just a time to talk about how we work on things, which is a great idea. And it's been helpful for talking about how we build things and non-functional requirements in specific areas of our jobs" (Developer). In another instance, a developer describes an experience of how he ensures that everyone who works on a project understands the NFRs when there is a change in scope. e.g "I'll set a meeting with everybody involved in the project. And if something changes, I'll make sure that everybody who is involved is together, and then we can actually hash it out and talk and then I'll usually take some kind of notes" (Developer). In addition, participants also describe their communication through Gather, as being key to facilitating several feedback cycles and meetings where it feels like they are working face-to-face. e.g. "I can think of one software that we use, which is Gather. And Gather is really obviously a video communication tool. I think it does foster the ability for individuals to kind of interact more. And by interacting more, and by kind of stopping by somebody's desk that you may not have talked to in a while, you can kind of ensure that communication of different departments is kind of happening, and it's happening more organically" (Manager). Through several feedback methods, we observed participants using question asking to reach a shared understanding of NFRs. A manager describes asking questions to clients to elicit the NFRs that are important to them during the early stages of discussing the project. e.g. "you want to ask a lot of questions, you want to poke a lot of holes and things and, really go to the very edge of, you know, when you're sketching it out. So yeah, I would say that initially, it's a lot of questions" (Manager). In a separate instance, a developer uses question asking to clarify an NFR and ensure that all members of the team have a good understanding of what the goal is. e.g Concerning usability, "And you have to ask questions and make sure that the person fully understands what the goal is. Sometimes things can be unclear, but so long as you're constantly asking questions, then the person is confident that they know what they're doing" (Developer). Furthermore, we asked participants about what methods of communication have been effective for reaching a shared understanding of NFRs. All of our participants mentioned Gather i.e, "And then we also have a virtual office environment called Gather, which is what we mainly use. I think Gather is good because it's more multimedia because you can talk and have video and share screens" (Developer). Finally, we asked participants when they know team members, inclusive of themselves, have a common or shared understanding of the NFRs. Developers describe this as when there is minimal feedback or questions during project meetings or conversations. e.g. "Like when we go into the 'deep-dive' we know when the non-functional requirements have been met, when we as a group meet, and there aren't gaps in our shared understanding. We come out of a review meeting and there's not a lot of feedback" (Developer). A manager describes this as when the team members are able to discuss the problems and solutions with each other and describe the behaviour of the software product e.g. "I'm kind of sufficiently satisfied with two conditions, what I think is a little bit more subjective, which is when the team members are starting to be able to explain the problem and understand the detailed nuance explain that problem to others. The other one is when you start to see like acceptance criteria that's really starting to look like one of our actual user acceptance tests. And by that point, you get a sense of if someone really understood the non-functional" (Manager). However, our participants acknowledge that shared understanding of NFRs should continue to evolve and there may not be a way to guarantee that there is a complete shared understanding of NFRs within the team at one time. A manager expresses this by saying "I don't actually think you can have [guarantee], honestly, until it's actually We asked participants if they experienced any challenges with understanding NFRs when working collaboratively. From our data analysis, we found five main themes that describe the limitations to a shared understanding of NFRs: gaps in communication, limited understanding of customer context, individual differences and unspecified NFRs. Additionally, we identified the main triggers across these limitations. The themes, triggers, and associated codes are in Table IV . In several instances, our participants describe gaps in communication within the software team and gaps in communication between the software team and the stakeholders due to unclear expectations for projects or assumptions about projects, which may lead to some rework or a change in the scope of a project. A manager describes a scenario in which the software team made inaccurate assumptions about what the stakeholders expected for a project regarding usability, which led to discussing additional requirements that were not within the scope of the project, "They had made the assumption that they would be able to go in and update these prints after launch. And Similarly, a participant expressed having experienced difficulty when working on a project and not understanding extensibility as an NFR. This difficulty was mainly due to a limited understanding of the customer and their products. e.g. " I think a lot of the confusion probably also came from it being my first couple projects here. And so I was still wrapping my head around what our customers actually are, how we interact with them, the full range of our products, and how they're planning on implementing their programs" (Developer). 3) Individual differences: Differences in the background, skills, experience and ideas of team members can sometimes lead to misunderstandings of NFRs, especially when there is no common foundation of knowledge. Alpha recognizes that having a diverse software team means that team members would have a different level of knowledge, skills and experience. e.g "the first thing that comes to mind when working with other team members, especially in a leadership position, is understanding that not every team member has the same level of technical or work experience as any other team member" (Manager). However, sometimes team members still make assumptions about how other members of the team think and how much they know and this may lead to a disparity in ideas about the product and how to implement the NFRs of the product. e.g. "But it just trickled down to things like the language we're using, just wasn't aligned even, people didn't even have the same ideas about what the functionality was. And that just like continued to trickle through the other nonfunctional requirements because it wasn't meeting some of the use cases anymore" (Developer). We observed that some of our participants experienced difficulties with understanding or implementing NFRs due to unclear or unspoken expectations around these NFRs. Concerning maintainability, how a code-base can be understood and built upon with well-written documentation, a software developer describes difficulties. e.g "Definitely, for the specification writing for that project, it was pretty difficult for me, because I wasn't really sure what they should look like. And also there weren't great examples that I could base it off" (Developer). When NFRs are not clearly defined, communicated or documented, developers are often left with their assumptions on what NFRs to include for a project and how to implement the NFRs. Our participants expressed that this could happen, however, due to the frequent feedback loops within the software team, there are several opportunities to communicate and re-elicit the NFRs relevant to the work being done. e.g "The thing is non-functional requirements are not always communicated as much... trying to figure out what or not, understanding or communicating expectations around some of those NFRs from stakeholders. The good thing about developing at Alpha is that our loops are pretty quick, we have a lot of communication, so becomes quite clear when something isn't being met. And when that comes up, just work to try and elicit what those requirements are" (Developer). CSE advocates for ongoing customer feedback and rapid iteration cycles [16] [22] , which should result in a higher level of understanding of customer requirements. However, prior research indicates that CSE may pose a detrimental effect on the shared understanding of non-functional requirements [48] . In remote organizations, building a shared understanding becomes more challenging due to the additional recognized barriers with remote work, such as challenges with information sharing and team members having a reduced ability to build trustworthy relationships [32] . Our work explores the delicate balance of achieving a shared understanding of NFRs in a remote CSE organization (Alpha), and in this section, we discuss the findings of our empirical study. Through our research, we uncovered five practices from Alpha to build a shared understanding of NFRs: validating NFRs through feedback, deepening the understanding of NFRs through experience, wireframing interface designs, discussing problems and solutions, and asking questions. We found some limitations within Alpha to building a shared understanding of NFRs, such as gaps in communication that may occur when team members make assumptions about each other's knowledge. We discuss how Alpha mitigates some challenges with building a shared understanding in a remote setting through multiple collaboration tools, particularly Gather. We believe these findings have important research implications concerning the intersection of shared understanding of NFRs and CSE in remote collaboration and how an organization could use practices that are proactive, rather than reactive, to build a shared understanding of NFRs. Glinz describes implicit shared understanding as the mutual understanding of non-specified facts or assumptions [22] . Our study suggests that Alpha relies on implicit shared understanding of NFRs, partly due to CSE practices that encourage frequent feedback [16] through formal, informal or face-toface communication [11] [13], as observed "a lot of getting to shared understanding is almost kind of unwritten" (Developer). Our findings corroborate and bring additional, empirical detail about the amount of implicit shared understanding, as four of the five practices used to develop a shared understanding of NFRs were in fact implicit, namely validating NFRs through feedback, deepening the understanding of NFRs through experience, discussing problems and solutions, and asking questions. Only a single practice, wireframing interface designs, was explicit in nature. Werner et al. describe the importance of the shared understanding of configuration management as configurability is an NFR that also encompasses process quality [49] , and supports the rapid development, configuration and deployment of software products. Prior research has described comprehensive configuration management [28] for continuous integration and continuous delivery as a key component of CSE. Many organizations use more than a single configuration tool, such as Docker, to create a software environment and applications, as observed by Werner et al. [49] within the three organizations in their study. An organization would benefit from continuous integration and delivery incorporated in CSE practices when they invest in building a shared understanding of NFRs such as configurability. Shared understanding is enhanced through the practices recommended by Werner et al. [48] , such as creating shared standards for configuration management and effective communication. At Alpha, developers use an in-house configuration tool for setting up their environment and application. Developers also use Process Street [40] , Coda, and GitHub for documenting configuration standards and collaboration, as these tools allow the developers to coordinate their activities around configuration management. Previous research analyzing surveys during the COVID-19 pandemic has suggested that effective communication is essential for a software team's productivity. Communication is often affected by changes in a team's culture and inefficient communication could pose a challenge to reaching milestones [39] . As CSE organizations rely on frequent feedback cycles, the quality of communication within software teams may suffer when team members work from a distance, i.e. work remotely [12] . However, our findings suggest that Alpha was able to mitigate some of the challenges in remote communication by using Gather, a virtual video conferencing tool that tries to simulate the face-to-face physical workspace "Gather has made it possible for us as a remote team to have informal conversations. You literally just walk your little character up to someone else's little character, and you're talking to them". Gather, a collaboration tool, has not been heavily researched on collaborative work and, to the best of our knowledge, in collaboration in software development. Our findings bring evidence about Gather's value in creating spaces that approach in-person interaction that is conducive to shared understanding in software engineering. A 2020 study of a distributed design team working during COVID-19 lockdowns [35] extensively used Zoom, Slack, and Google docs, identified difficulties with establishing a team spirit in a distributed setting due to the limited one-view per participant experience with Zoom meetings during group sketching and the difficulties with understanding the team member's progress. At Alpha, we believe that Gather has allowed Alpha to achieve the practices suggested by this study for mitigating the challenge of simulating a co-located design space and encouraging screensharing for remote collaboration. A key enabler for shared understanding is the ability to ask questions and receive feedback, regardless of background experience, education, or other demographic factors [7] , that we identified as asking question in our practices for building a shared understanding. Previous research suggests other enablers of shared understanding in remote teams such as visualizing information, online updates and trustworthiness [32] . We further discuss our insights about these enablers at Alpha. First, we observed that Alpha uses wireframing for interface designs and screen-sharing to enable the team to set and understand the expectations for NFRs. This observation supports prior research on building shared understanding for supporting remote teams through building shared mental models with visual representations [23] . Second, frequent communication ensures that there is a shared understanding of how team members feel and how the project progresses [32] . Online updates like daily check-ins on Slack or formal or informal communication on Gather shows the importance of multiple forms of communication media [30] [26] and tools such as Gather, Slack, and file sharing. Third, mutual trust enables team members to collaborate and share feedback openly, thus improving shared understanding within remote teams [32] . Previous research suggests that regular communication, including formal and informal communication, plays a vital role in creating relationships within remote teams and thus in building trust within the team, regardless of the difference in background, location or culture [25] . Alpha built trust within the team mainly through informal communication on Gather or Slack, where team members are open to seeking help from each other, as observed "If someone sends me a quick Slack message, and I look at it ... I will go straight to their desk and start to engage them in conversation so that we can whiteboard it or work through the problem". Through observations and the practices we identified in our study, we bring empirical evidence that further adds to and enhances the work by Werner et al. [48] on the recommended practices for building shared understanding i.e., how team communication and shared development standards form the fundamental base for building a shared understanding. In addition, we have identified a new practice of building a shared understanding through experience. Our first practice, discussing problems and solutions, is part of utilizing communication to develop a shared understanding. Developers can also initiate the creation of a shared understanding by asking questions, which is another form of communication. Validating NFRs through feedback is a form of communication that can happen through the continuous pipeline or in a meeting; regardless of how that communication takes place, the emphasis is on the continuous validation of NFRs that can build a shared understanding. An organization can leverage wireframes for interface designs, a form of shared development standards, that may enhance the proliferation of a shared understanding. Finally, developers can deepen their understanding of NFRs through experience at their organization and how that particular organization values NFRs. Werner et al. [48] observed that an organization builds a shared understanding of NFRs primarily due to a reactive response to accidental lack of shared understanding, related to various reasonstriggers -such as scope creep, rework, regulatory requirements, accumulating technical debt, needs of an important customer, or a disruption of service. In Table III , we show the triggers that emerged from our data analysis and how they correspond to the identified practices. In the practices we observed at Alpha, the deepening the understanding of NFRs through experience is an example of such a reactive response, or where our data does not indicate that the response was the result of any of these or other triggers. However, we categorized four of the five practices we identified at Alpha as being proactive in many instances, even though they were reactive in a few instances. One practice in particular sheds more light on how Alpha adapted to working and building shared understanding in remote settings: wireframing interface designs. Prior research suggests that using virtual shared spaces that enable the team to visualize solutions and interact with visualizations encourages better communication and enables shared understanding [3] . Through Gather's virtual shared space and screen-sharing feature, Alpha used tools such as Figma, an online whiteboard for visual representations with elements like blocks and shapes, to support collaboration with team members, thereby enabling the team to develop a shared understanding more quickly, as observed in prior research [3] . We observed that a proactive effort to build a shared understanding may not require a formal process or documentation. The loose agenda of these meetings is rather informal and lends to the creative discussions around NFRs. Our findings indicate that tools such as Gather offer a medium for these informal, yet important, conversations to occur. Developers at Alpha unanimously describe Gather as a method that has created a sense of being connected to each other, despite their remote setting. "I think Gather town has really helped with that, it's just a place where you can feel like you're next to the people that you're working with". Our findings have practical implications to software organizations as they show that while there is still a considerable amount of shared understanding built through reactive measures, there is also a sizable amount that is a direct result of some proactive practices. One developer indicated that he found some NFRs as follows: "as you're going down into more details, during something like a journey map, that's where you start bumping into the non-functional requirements that may not have been clearly identified". However, when it comes to such NFRs, discussions did not happen until much later, as one participant noted, "that's when you really start the back and forth communication on how you're going to address them...So I think it's during that process of drilling down into the details on how a project is going to be run, that you start hitting them, and the NFRs". Despite the complexity and importance of NFRs [47] [2] , previous research observes that software developers discover NFRs during or after the software product implementation [38] . Eliciting NFRs at this stage may pose a challenge that could affect the entire software development process or lead to delays in software [38] [47] ; therefore, it is prudent for an organization to ensure the conversations about NFRs are occurring early enough to facilitate building a shared understanding. The definition of when is left for future work; however, given the effects of architectural decisions on NFRs (or lack thereof), a shared understanding should be continually built throughout the development cycle, perhaps allotting enough time for "just-in-time" engineering [15] . We acknowledge the limitations of our qualitative study through four components of the total quality framework [42] : credibility, analyzability, transparency and usefulness. For the credibility, the selection of Alpha may suffer from sampling bias as we focused on an organization willing to partner with us; however, we verified that their practices align with CSE through observation by one of our researchers. In addition, we interviewed participants with various roles and levels of experience. To limit conscious or unconscious bias during data collection, we explained that study participation was completely anonymous and would not cause any consequence or risk to the participants. We started each interview session by exploring the definition of shared understanding. Afterwards, we explained shared understanding in the context of our research with examples to ensure that each participant had the same level of knowledge about shared understanding. For analyzability, we used a transcription tool on the recorded audio from the interviews and one of the authors listened and verified each transcript. We used thematic analysis through the open, axial, and selective coding process from grounded theory [27] ; we describe this process in Section III. We used the inter-rater agreement process [34] to align our codes and categories within our coding scheme. We used reflective memos during the coding process to describe patterns observed in the data collected for reference. For transparency, we provide a replication package (https://doi.org/10.5281/zenodo.6273497) with our codebook, interview questions, and data about our inter-rater agreement sessions; however confidential data are excluded due to our non-disclosure agreement. Although we believe we reached saturation of codes in our data analysis, one limitation to our coding process may be the subjectivity of the exhaustiveness of our codes which may influence research results. For usefulness, we do not propose that our results and findings hold true for all remote CSE organizations. We acknowledge that our single case study research provides results limited to our partner organization. However, to increase the usefulness of our findings, more case studies like ours would be helpful with a focus on how remote software organizations can proactively build and maintain a shared understanding of NFRs, and how to evaluate a shared understanding of NFRs. A shared understanding of NFRs is important for the success of many software projects. However, managing NFRs can pose a significant challenge to software organizations due to factors such as the conflicting nature of NFRs and the lack of shared understanding of NFRs. In addition, shared understanding of NFRs in CSE is still understudied and there is insufficient literature to show how organizations can effectively build a shared understanding. While prior research has explored how NFRs are managed in CSE, considering the challenges and best practices for managing NFRs, there is still the question of how CSE organizations can build a shared understanding of NFRs. This paper describes the practices for building a shared understanding of NFRs, through a case study of a remote CSE organization. Through discussing the practices for building a shared understanding of NFRs in CSE, we observe that CSE organizations are proactively building a shared understanding, although still reactively building a shared understanding in several instances. Furthermore, we discuss the limitations to a shared understanding of NFRs in CSE, highlighting the similarities and differences between the limitations described in our study and prior research. With respect to the practical implications of our study, we acknowledge the limitations to our research as a single-case study, however, we believe that our research adds valuable empirical evidence to this research area and is a useful starting point to further explore how CSE organizations can build a shared understanding of NFRs. In future research, we seek to evaluate the effectiveness of proactive practices for building a shared understanding of NFRs in CSE. A framework for considering opportunities and threats in distributed software development How do software architects consider non-functional requirements: An exploratory study Do visualizations improve synchronous remote collaboration? Extreme programming explained: embrace change Work from home after the COVID-19 Outbreak Why shared understanding matters-Engineering a collaboration process for shared understanding to improve collaboration effectiveness in heterogeneous teams Supporting the development of shared understanding in distributed design teams Cloud storage for work and home -Google Drive Coda -The doc that brings it all together Shared understanding of end-users' requirements in e-Science projects Challenges when adopting continuous integration: A case study Remote working and collaboration in agile teams Effective communication in distributed Agile software development teams Uncovering the benefits and challenges of continuous integration practices Case studies in justin-time requirements analysis Continuous software engineering: A roadmap and agenda The agile manifesto Gather -A better way to meet online Virtual teams that work: Creating conditions for virtual team effectiveness GitHub: Where the world builds software . GitHub On non-functional requirements On shared understanding in software engineering: an essay To see eye to eye: the role of visual representations in building shared mental models in design teams Neurodivergent intersubjectivity: Distinctive features of how autistic people create shared understanding Managing distance in a global virtual team: the evolution of trust through technology-mediated relational communication Knowledge sharing and shared understanding in virtual teams Grounded theory for geeks Continuous delivery sounds great, but will it work here? Practitioners' eye on continuous software engineering: An interview study Perceptions of success in virtual cross-disciplinary design teams in large multinational corporations Thematic analysis of qualitative data: AMEE Guide No. 131 Riding the Same Wavelength: Designers' Perceptions of Shared Understanding in Remote Teams Informal communication in organizations: Form, function, and technology The measurement of observer agreement for categorical data Distributed synchronous visualization design: Challenges and strategies An investigation into the notion of non-functional requirements Managing conflicts among non-functional requirements A survey of nonfunctional requirements in software development process Software Development Teams Working From Home During COVID-19 Process Street -Checklist, Workflow and SOP Software Analyzing collaborative interactions: Divergence, shared understanding and construction of knowledge Applied qualitative research design: A total quality framework approach Estimating the contextual risk of data breach: An empirical approach Spotify guilds: how to succeed with knowledge sharing in large-scale agile organizations Supporting Informal Communication in Distributed Engineering Design Teams A survey on issues in non-functional requirements elicitation The Lack of Shared Understanding of Non-Functional Requirements in Continuous Software Engineering: Accidental or Essential? Continuously managing NFRs: Opportunities and challenges in practice We thank our partner organization and employees for their time and collaboration. We acknowledge Nowshin Nawar Arony and Neha Koulecar (University of Victoria) for their assistance in our study. Our research was supported by the Natural Sciences and Engineering Research Council of Canada (NSERC).