{"id":2216,"date":"2019-03-26T22:43:05","date_gmt":"2019-03-27T03:43:05","guid":{"rendered":"https:\/\/rpchurchill.com\/wordpress\/?p=2216"},"modified":"2019-04-04T01:00:06","modified_gmt":"2019-04-04T06:00:06","slug":"combined-survey-results-late-march-2019","status":"publish","type":"post","link":"https:\/\/rpchurchill.com\/wordpress\/posts\/2019\/03\/26\/combined-survey-results-late-march-2019\/","title":{"rendered":"Combined Survey Results (late March 2019)"},"content":{"rendered":"

The additional survey results from yesterday<\/a> are included in the combined results here.<\/p>\n

List at least five steps you take during a typical business analysis effort.<\/span><\/p>\n

    \n
  1. Requirements Gathering<\/li>\n
  2. Initiation<\/li>\n
  3. Testing<\/li>\n
  4. QA<\/li>\n
  5. Feedback<\/li>\n
  6. User acceptance<\/li>\n<\/ol>\n
      \n
    1. Requirement Elicitation<\/li>\n
    2. UX Design<\/li>\n
    3. Software Design for Testability<\/li>\n<\/ol>\n
        \n
      1. Identify Business Goal<\/li>\n
      2. ID Stakeholders<\/li>\n
      3. Make sure necessary resources are available<\/li>\n
      4. Create Project Schedule<\/li>\n
      5. Conduct regular status meetings<\/li>\n<\/ol>\n
          \n
        1. Meet with requester to learn needs\/wants<\/li>\n
        2. List details\/wants\/needs<\/li>\n
        3. Rough draft of Project\/proposed solutions<\/li>\n
        4. Check in with requester on rough draft<\/li>\n
        5. Make edits\/adjustments | test<\/li>\n
        6. Regularly schedule touch-point meeting<\/li>\n
        7. Requirement analysis\/design | functional\/non-functional<\/li>\n
        8. Determine stakeholders | user acceptance<\/li>\n<\/ol>\n
            \n
          1. List the stakeholders<\/li>\n
          2. Read through all documents available<\/li>\n
          3. Create list of questions<\/li>\n
          4. Meet regularly with the stakeholders<\/li>\n
          5. Meet with developers<\/li>\n
          6. Develop scenarios<\/li>\n
          7. Ensure stakeholders ensersy requirements<\/li>\n
          8. other notes<\/li>\n
              \n
            • SMART PM milestones<\/li>\n
            • know players<\/li>\n
            • feedback<\/li>\n
            • analysis steps<\/li>\n
            • no standard<\/li>\n<\/ul>\n<\/ol>\n
                \n
              1. identify stakeholders \/ Stakeholder Analysis<\/li>\n
              2. identify business objectives \/ goals<\/li>\n
              3. identify use cases<\/li>\n
              4. specify requirements<\/li>\n
              5. interview Stakeholders<\/li>\n<\/ol>\n
                  \n
                1. project planning<\/li>\n
                2. user group sessions<\/li>\n
                3. individual meetings<\/li>\n
                4. define business objectives<\/li>\n
                5. define project scope<\/li>\n
                6. prototype \/ wireframes<\/li>\n<\/ol>\n
                    \n
                  1. identify audience \/ stakeholders<\/li>\n
                  2. identify purpose and scope<\/li>\n
                  3. develop plan<\/li>\n
                  4. define problem<\/li>\n
                  5. identify objective<\/li>\n
                  6. analyze problems \/ identify alternative solutions<\/li>\n
                  7. determine solution to go with<\/li>\n
                  8. design solution<\/li>\n
                  9. test solution<\/li>\n<\/ol>\n
                      \n
                    1. gathering requirements<\/li>\n
                    2. assess stakeholder priorities<\/li>\n
                    3. data pull<\/li>\n
                    4. data scrub<\/li>\n
                    5. data analysis<\/li>\n
                    6. create summary presentation<\/li>\n<\/ol>\n
                        \n
                      1. define objective<\/li>\n
                      2. research available resources<\/li>\n
                      3. define a solution<\/li>\n
                      4. gather its requirements<\/li>\n
                      5. define requirements<\/li>\n
                      6. validate and verify requirements<\/li>\n
                      7. work with developers<\/li>\n
                      8. coordinate building the solutions<\/li>\n<\/ol>\n
                          \n
                        1. requirements elicitation<\/li>\n
                        2. requirements analysis<\/li>\n
                        3. get consensus<\/li>\n
                        4. organizational architecture assessment<\/li>\n
                        5. plan BA activities<\/li>\n
                        6. assist UAT<\/li>\n
                        7. requirements management<\/li>\n
                        8. define problem to be solved<\/li>\n<\/ol>\n
                            \n
                          1. understand thhe business need of the request<\/li>\n
                          2. understand why the need is important – what is the benefit\/value?<\/li>\n
                          3. identify the stakeholders affected by the request<\/li>\n
                          4. identify system and process impacts of the change (complexity of the change)<\/li>\n
                          5. understand the cost of the change<\/li>\n
                          6. prioritize the request in relation to other requests\/needs<\/li>\n
                          7. elicit business requirements<\/li>\n
                          8. obtain signoff on business requests \/ validate requests<\/li>\n<\/ol>\n
                              \n
                            1. understanding requirements<\/li>\n
                            2. writing user stories<\/li>\n
                            3. participating in Scrums<\/li>\n
                            4. testing stories<\/li>\n<\/ol>\n
                                \n
                              1. research<\/li>\n
                              2. requirements meetings\/elicitation<\/li>\n
                              3. document requirements<\/li>\n
                              4. requirements approvals<\/li>\n
                              5. estimation with developers<\/li>\n
                              6. consult with developers<\/li>\n
                              7. oversee UAT<\/li>\n
                              8. oversee business transition<\/li>\n<\/ol>\n
                                  \n
                                1. brainstorming<\/li>\n
                                2. interview project owner(s)<\/li>\n
                                3. understand current state<\/li>\n
                                4. understand need \/ desired state<\/li>\n
                                5. simulate \/ shadow<\/li>\n
                                6. inquire about effort required from technical team<\/li>\n<\/ol>\n
                                    \n
                                  1. scope, issue determination, planning<\/li>\n
                                  2. define issues<\/li>\n
                                  3. define assumptions<\/li>\n
                                  4. planning<\/li>\n
                                  5. ccommunication<\/li>\n
                                  6. analysis – business and data modeling<\/li>\n<\/ol>\n
                                      \n
                                    1. gather data<\/li>\n
                                    2. sort<\/li>\n
                                    3. define<\/li>\n
                                    4. organize<\/li>\n
                                    5. examples, good and bad<\/li>\n<\/ol>\n
                                        \n
                                      1. document analysis<\/li>\n
                                      2. interviews<\/li>\n
                                      3. workshops<\/li>\n
                                      4. BRD walkthroughs<\/li>\n
                                      5. item tracking<\/li>\n<\/ol>\n
                                          \n
                                        1. ask questions<\/li>\n
                                        2. gather data<\/li>\n
                                        3. clean data<\/li>\n
                                        4. run tests<\/li>\n
                                        5. interpret results<\/li>\n
                                        6. visualize results<\/li>\n
                                        7. provide conclusions<\/li>\n<\/ol>\n
                                            \n
                                          1. understand current state<\/li>\n
                                          2. understand desired state<\/li>\n
                                          3. gap analysis<\/li>\n
                                          4. understand end user<\/li>\n
                                          5. help customer update desired state\/vision<\/li>\n
                                          6. deliver prioritized value iteratively<\/li>\n<\/ol>\n
                                              \n
                                            1. define goals and objectives<\/li>\n
                                            2. model As-Is<\/li>\n
                                            3. identify gaps\/requirements<\/li>\n
                                            4. model To-Be<\/li>\n
                                            5. define business rules<\/li>\n
                                            6. conduct impact analysis<\/li>\n
                                            7. define scope<\/li>\n
                                            8. identify solution \/ how<\/li>\n<\/ol>\n
                                                \n
                                              1. interview project sponsor<\/li>\n
                                              2. interview key stakeholders<\/li>\n
                                              3. read relevant information about the issue<\/li>\n
                                              4. form business plan<\/li>\n
                                              5. communicate and get buy-in<\/li>\n
                                              6. goals, objectives, and scope<\/li>\n<\/ol>\n
                                                  \n
                                                1. stakeholder analysis<\/li>\n
                                                2. requirements gathering<\/li>\n
                                                3. requirements analysis<\/li>\n
                                                4. requirements management – storage and updates<\/li>\n
                                                5. communication – requirements and meetings<\/li>\n<\/ol>\n
                                                    \n
                                                  1. analyze evidence<\/li>\n
                                                  2. desiign application<\/li>\n
                                                  3. develop prototype<\/li>\n
                                                  4. implement product<\/li>\n
                                                  5. evaluate product<\/li>\n
                                                  6. train users<\/li>\n
                                                  7. upgrade functionality<\/li>\n<\/ol>\n
                                                      \n
                                                    1. read material from previous similar projects<\/li>\n
                                                    2. talk to sponsors<\/li>\n
                                                    3. web search on topic<\/li>\n
                                                    4. play with current system<\/li>\n
                                                    5. ask questions<\/li>\n
                                                    6. draw BPMs<\/li>\n
                                                    7. write use cases<\/li>\n<\/ol>\n
                                                        \n
                                                      1. document current process<\/li>\n
                                                      2. identify users<\/li>\n
                                                      3. meet with users; interview<\/li>\n
                                                      4. review current documentation<\/li>\n
                                                      5. present proposed solution or iteration<\/li>\n<\/ol>\n
                                                          \n
                                                        1. meeting with stakeholders<\/li>\n
                                                        2. outline scope<\/li>\n
                                                        3. research<\/li>\n
                                                        4. write requirements<\/li>\n
                                                        5. meet and verify with developers<\/li>\n
                                                        6. test in development and production<\/li>\n
                                                        7. outreach and maintenance with stakeholders<\/li>\n<\/ol>\n
                                                            \n
                                                          1. As-In analysis (current state)<\/li>\n
                                                          2. write lightweight business case<\/li>\n
                                                          3. negotiate with stakeholders<\/li>\n
                                                          4. write user stories<\/li>\n
                                                          5. User Acceptance Testing<\/li>\n
                                                          6. cry myself to sleep \ud83d\ude42<\/li>\n<\/ol>\n
                                                              \n
                                                            1. initiation<\/li>\n
                                                            2. elicitation<\/li>\n
                                                            3. discussion<\/li>\n
                                                            4. design \/ user stories \/ use cases<\/li>\n
                                                            5. sign-off<\/li>\n
                                                            6. sprints<\/li>\n
                                                            7. testing \/ QA<\/li>\n
                                                            8. user acceptance testing<\/li>\n<\/ol>\n
                                                                \n
                                                              1. planning<\/li>\n
                                                              2. elicitation<\/li>\n
                                                              3. requirements<\/li>\n
                                                              4. specification writing<\/li>\n
                                                              5. QA<\/li>\n
                                                              6. UAT<\/li>\n<\/ol>\n
                                                                  \n
                                                                1. identify the problem<\/li>\n<\/ol>\n
                                                                    \n
                                                                  1. studying subject matter<\/li>\n
                                                                  2. planning<\/li>\n
                                                                  3. elicitation<\/li>\n
                                                                  4. functional specification writing<\/li>\n
                                                                  5. documentation<\/li>\n<\/ol>\n
                                                                      \n
                                                                    1. identify stakeholders<\/li>\n
                                                                    2. assess working approach (Waterfall, Agile, Hybrid)<\/li>\n
                                                                    3. determine current state of requirements and maturity of project vision<\/li>\n
                                                                    4. interview stakeholders<\/li>\n
                                                                    5. write and validate requirements<\/li>\n<\/ol>\n
                                                                        \n
                                                                      1. problem definition<\/li>\n
                                                                      2. value definition<\/li>\n
                                                                      3. decomposition<\/li>\n
                                                                      4. dependency analysis<\/li>\n
                                                                      5. solution assessment<\/li>\n<\/ol>\n
                                                                          \n
                                                                        1. process mapping<\/li>\n
                                                                        2. stakeholder interviews<\/li>\n
                                                                        3. write use cases<\/li>\n
                                                                        4. document requirements<\/li>\n
                                                                        5. research<\/li>\n<\/ol>\n
                                                                            \n
                                                                          1. listen – to stakeholders and customers<\/li>\n
                                                                          2. analyze – documents, data, atc. to understand thhings further<\/li>\n
                                                                          3. repeat back what I’m hearing to make sure I’m understanding correctly<\/li>\n
                                                                          4. synthesize – the details<\/li>\n
                                                                          5. document – as needed(e.g., Visio diagramsPowerPoint decks, Word, tool, etc.)<\/li>\n
                                                                          6. solution<\/li>\n
                                                                          7. help with implementing<\/li>\n
                                                                          8. assess and improve – if\/as needed<\/li>\n<\/ol>\n
                                                                              \n
                                                                            1. understand the problem<\/li>\n
                                                                            2. understand the environment<\/li>\n
                                                                            3. gather the requirements<\/li>\n
                                                                            4. align with IT on design<\/li>\n
                                                                            5. test<\/li>\n
                                                                            6. train<\/li>\n
                                                                            7. deploy<\/li>\n
                                                                            8. follow-up<\/li>\n<\/ol>\n
                                                                                \n
                                                                              1. watch how it is currently done<\/li>\n
                                                                              2. listen to clients’ pain points<\/li>\n
                                                                              3. define goals of project<\/li>\n<\/ol>\n
                                                                                  \n
                                                                                1. critical path tasks<\/li>\n
                                                                                2. pros\/cons of tasks<\/li>\n
                                                                                3. impacts<\/li>\n
                                                                                4. risks<\/li>\n
                                                                                5. goals<\/li>\n<\/ol>\n
                                                                                    \n
                                                                                  1. discovery – high level<\/li>\n
                                                                                  2. analysis \/ evaluation<\/li>\n
                                                                                  3. presentation of options<\/li>\n
                                                                                  4. requirements gathering<\/li>\n
                                                                                  5. epic \/ feature \/ story definition’<\/li>\n
                                                                                  6. prioritization<\/li>\n<\/ol>\n
                                                                                      \n
                                                                                    1. who is driving the requirements?<\/li>\n
                                                                                    2. focus on what is needed for project<\/li>\n
                                                                                    3. who is going to use the product?<\/li>\n<\/ol>\n
                                                                                        \n
                                                                                      1. elicit requirements<\/li>\n
                                                                                      2. hold focus groups<\/li>\n
                                                                                      3. create mock-ups<\/li>\n
                                                                                      4. test<\/li>\n
                                                                                      5. write user stories<\/li>\n<\/ol>\n
                                                                                          \n
                                                                                        1. analyze<\/li>\n
                                                                                        2. document process<\/li>\n
                                                                                        3. identify waste (Lean)<\/li>\n
                                                                                        4. communicate<\/li>\n
                                                                                        5. document plan \/ changes<\/li>\n<\/ol>\n
                                                                                            \n
                                                                                          1. meeting<\/li>\n
                                                                                          2. documentation<\/li>\n
                                                                                          3. strategy<\/li>\n
                                                                                          4. execution plan<\/li>\n
                                                                                          5. reporting plan<\/li>\n<\/ol>\n
                                                                                              \n
                                                                                            1. requirements gathering<\/li>\n
                                                                                            2. delivery expectations<\/li>\n
                                                                                            3. user experience work with customer<\/li>\n
                                                                                            4. process mapping<\/li>\n
                                                                                            5. system and user testing<\/li>\n
                                                                                            6. system interaction (upstram and downstream) how does a change affect my process?<\/li>\n
                                                                                            7. understanding stakeholders<\/li>\n<\/ol>\n
                                                                                                \n
                                                                                              1. stakeholder elicitation<\/li>\n
                                                                                              2. brainstorming<\/li>\n
                                                                                              3. requirements analysis<\/li>\n
                                                                                              4. wireframing<\/li>\n
                                                                                              5. process \/ flow diagrams<\/li>\n<\/ol>\n
                                                                                                  \n
                                                                                                1. current state analysis<\/li>\n
                                                                                                2. future state<\/li>\n
                                                                                                3. gap analysis<\/li>\n
                                                                                                4. requirements gathering<\/li>\n
                                                                                                5. success metrics<\/li>\n<\/ol>\n
                                                                                                    \n
                                                                                                  1. interview users<\/li>\n
                                                                                                  2. gather requirements<\/li>\n
                                                                                                  3. document business rules<\/li>\n
                                                                                                  4. business process flow<\/li>\n
                                                                                                  5. mock-ups<\/li>\n<\/ol>\n
                                                                                                      \n
                                                                                                    1. UX design review<\/li>\n
                                                                                                    2. requirements gathering<\/li>\n
                                                                                                    3. vision gathering \/ understanding<\/li>\n<\/ol>\n
                                                                                                        \n
                                                                                                      1. requirements elicitation<\/li>\n
                                                                                                      2. gap analysis<\/li>\n<\/ol>\n
                                                                                                          \n
                                                                                                        1. shadow users<\/li>\n
                                                                                                        2. follow up to verify understanding of business and need<\/li>\n
                                                                                                        3. mockups, high-level design concept<\/li>\n
                                                                                                        4. present mockup, design concept<\/li>\n
                                                                                                        5. create and mintain stories and acceptance criteria<\/li>\n<\/ol>\n
                                                                                                            \n
                                                                                                          1. brainstorming<\/li>\n
                                                                                                          2. external stakeholder feedback<\/li>\n
                                                                                                          3. internal stakeholder feedback<\/li>\n
                                                                                                          4. break down epics<\/li>\n
                                                                                                          5. user stories<\/li>\n
                                                                                                          6. building<\/li>\n<\/ol>\n
                                                                                                              \n
                                                                                                            1. stakeholder analysis<\/li>\n
                                                                                                            2. elicitation activity plan<\/li>\n
                                                                                                            3. requirements tracing<\/li>\n
                                                                                                            4. prototyping<\/li>\n
                                                                                                            5. document analysis<\/li>\n<\/ol>\n
                                                                                                                \n
                                                                                                              1. research<\/li>\n
                                                                                                              2. requirements analysis<\/li>\n
                                                                                                              3. state chart diagram<\/li>\n
                                                                                                              4. execution plan<\/li>\n
                                                                                                              5. reporting plan<\/li>\n<\/ol>\n

                                                                                                                List some steps you took in a weird or non-standard project.<\/span><\/p>\n

                                                                                                                  \n
                                                                                                                • Steps:<\/li>\n
                                                                                                                    \n
                                                                                                                  1. 1. Why is there a problem? Is there a problem?<\/li>\n
                                                                                                                  2. 2. What can change? How can I change it?<\/li>\n
                                                                                                                  3. 3. How to change the process for lasting results<\/li>\n<\/ol>\n
                                                                                                                  4. A description of “weird” usually goes along with a particular person I am working with rather than a project. Some people like things done a certain way or they need things handed to them or their ego stroked. I accommodate all kinds of idiosyncrasies so that I can get the project done on time.<\/li>\n
                                                                                                                  5. adjustments in project resources<\/li>\n
                                                                                                                  6. after initial interview, began prototyping and iterated through until agreed upon design<\/li>\n
                                                                                                                  7. built a filter<\/li>\n
                                                                                                                  8. create mock-ups and gather requirements<\/li>\n
                                                                                                                  9. create strategy to hit KPIs<\/li>\n
                                                                                                                  10. data migration<\/li>\n
                                                                                                                  11. data dictionary standardization<\/li>\n
                                                                                                                  12. describing resource needs to the customer so they better understand how much work actually needs to happen and that there isn’t enough staff<\/li>\n
                                                                                                                  13. design sprint<\/li>\n
                                                                                                                  14. design thinking<\/li>\n
                                                                                                                  15. developers and I create requirements as desired<\/li>\n
                                                                                                                  16. did my own user experience testing<\/li>\n
                                                                                                                  17. document requirements after development work has begun<\/li>\n
                                                                                                                  18. documented non-value steps in a process new to me<\/li>\n
                                                                                                                  19. explained project structure to stakeholders<\/li>\n
                                                                                                                  20. For a client who was unable to clearly explain their business processes and where several SMEs had to be consulted to form the whole picture, I drew workflows to identify inputs\/outputs, figure out where the gaps in our understanding existed, and identify the common paths and edge cases.<\/li>\n
                                                                                                                  21. got to step 6 (building) and started back at step 1 multiiple times<\/li>\n
                                                                                                                  22. guided solutioning<\/li>\n
                                                                                                                  23. identified handoffs between different contractors<\/li>\n
                                                                                                                  24. identify end results<\/li>\n
                                                                                                                  25. interview individuals rather than host meetings<\/li>\n
                                                                                                                  26. investigate vendor-provided code for business process flows<\/li>\n
                                                                                                                  27. iterative development and delivery<\/li>\n
                                                                                                                  28. made timeline promises to customers without stakeholder buy-in\/signoff<\/li>\n
                                                                                                                  29. make excutive decisions withoutstakeholder back-and-forth<\/li>\n
                                                                                                                  30. mapped a process flow on a meeting room wall and had developers stick up arrows and process boxes like I would create in Visio to get engagement and consensus<\/li>\n
                                                                                                                  31. moved heavy equipment<\/li>\n
                                                                                                                  32. moved servers from one office to another<\/li>\n
                                                                                                                  33. observe people doing un-automated process<\/li>\n
                                                                                                                  34. personally evaluate how comitted mgt was to what they said they wanted<\/li>\n
                                                                                                                  35. phased delivery \/ subject areas<\/li>\n
                                                                                                                  36. physically simulate each step of an operational process<\/li>\n
                                                                                                                  37. process development<\/li>\n
                                                                                                                  38. regular status reports to CEO<\/li>\n
                                                                                                                  39. resources and deliverables<\/li>\n
                                                                                                                  40. reverse code engineering<\/li>\n
                                                                                                                  41. review production incident logs<\/li>\n
                                                                                                                  42. showed customer a competitor’s website to get buy-in for change<\/li>\n
                                                                                                                  43. simulation<\/li>\n
                                                                                                                  44. start with techniques from junior team members<\/li>\n
                                                                                                                  45. starting a project without getting agreed funding from various units<\/li>\n
                                                                                                                  46. statistical modeling<\/li>\n
                                                                                                                  47. surveys<\/li>\n
                                                                                                                  48. team up with PM to develop a plan to steer the sponsor in the right diection<\/li>\n
                                                                                                                  49. town halls<\/li>\n
                                                                                                                  50. track progress in PowerPoint because the sponsor insisted on it<\/li>\n
                                                                                                                  51. train the team how to read use case diagrams<\/li>\n
                                                                                                                  52. translating training documents into Portuguese<\/li>\n
                                                                                                                  53. travel to affiliate sites to understand their processes<\/li>\n
                                                                                                                  54. understanding cultural and legal requirements in a foreign country<\/li>\n
                                                                                                                  55. use a game<\/li>\n
                                                                                                                  56. using a ruler to estimate level of effort to digitize paper contracts in filing cabinets gathered over 40 years<\/li>\n
                                                                                                                  57. work around manager who was afraid of change – had to continually demonstrate the product, ease of use, and savings<\/li>\n
                                                                                                                  58. worked with a mechanic<\/li>\n
                                                                                                                  59. write requirements for what had been developed<\/li>\n<\/ul>\n

                                                                                                                    Name three software tools you use most.<\/span><\/p>\n

                                                                                                                      \n
                                                                                                                    • Excel (27)<\/li>\n
                                                                                                                    • Visio (18)<\/li>\n
                                                                                                                    • Jira (17)<\/li>\n
                                                                                                                    • Word (15)<\/li>\n
                                                                                                                    • Confluence (8)<\/li>\n
                                                                                                                    • Outlook (7)<\/li>\n
                                                                                                                    • PowerPoint (7)<\/li>\n
                                                                                                                    • SharePoint (6)<\/li>\n
                                                                                                                    • Azure DevOps (5)<\/li>\n
                                                                                                                    • Google Docs (4)<\/li>\n
                                                                                                                    • MS Team Foundation Server (4)<\/li>\n
                                                                                                                    • email (3)<\/li>\n
                                                                                                                    • MS Teams (3)<\/li>\n
                                                                                                                    • Draw.io (2)<\/li>\n
                                                                                                                    • MS Dynamics (2)<\/li>\n
                                                                                                                    • MS Office (2)<\/li>\n
                                                                                                                    • MS Visual Studio (2)<\/li>\n
                                                                                                                    • Notepad (2)<\/li>\n
                                                                                                                    • OneNote (2)<\/li>\n
                                                                                                                    • Siebel (2)<\/li>\n
                                                                                                                    • Slack (2)<\/li>\n
                                                                                                                    • SQL Server (2)<\/li>\n
                                                                                                                    • Version One (2)<\/li>\n
                                                                                                                    • Adobe Reader (1)<\/li>\n
                                                                                                                    • all MS products (1)<\/li>\n
                                                                                                                    • ARC \/ Knowledge Center(?) (Client Internal Tests) (1)<\/li>\n
                                                                                                                    • Balsamiq (1)<\/li>\n
                                                                                                                    • Basecamp (1)<\/li>\n
                                                                                                                    • Blueprint (1)<\/li>\n
                                                                                                                    • Bullhorn (1)<\/li>\n
                                                                                                                    • CRM (1)<\/li>\n
                                                                                                                    • database, spreadsheet, or requirement tool for managing requirements (1)<\/li>\n
                                                                                                                    • Doors (1)<\/li>\n
                                                                                                                    • Enbevu(?) (Mainframe) (1)<\/li>\n
                                                                                                                    • Enterprise Architect (1)<\/li>\n
                                                                                                                    • Gephi (dependency graphing) (1)<\/li>\n
                                                                                                                    • Google Calendar (1)<\/li>\n
                                                                                                                    • Google Drawings (1)<\/li>\n
                                                                                                                    • illustration \/ design program for diagrams (1)<\/li>\n
                                                                                                                    • iRise (1)<\/li>\n
                                                                                                                    • Kingsway Soft (1)<\/li>\n
                                                                                                                    • Lucid Chart (1)<\/li>\n
                                                                                                                    • LucidChart (1)<\/li>\n
                                                                                                                    • Miro Real-Time Board (1)<\/li>\n
                                                                                                                    • MS Office tools (1)<\/li>\n
                                                                                                                    • MS Project (1)<\/li>\n
                                                                                                                    • MS Word developer tools (1)<\/li>\n
                                                                                                                    • NUnit (1)<\/li>\n
                                                                                                                    • Pendo (1)<\/li>\n
                                                                                                                    • Power BI (1)<\/li>\n
                                                                                                                    • Process 98 (1)<\/li>\n
                                                                                                                    • Python (1)<\/li>\n
                                                                                                                    • R (1)<\/li>\n
                                                                                                                    • requirements repositories, e.g., RRC, RTC (1)<\/li>\n
                                                                                                                    • RoboHelp (1)<\/li>\n
                                                                                                                    • Scribe (1)<\/li>\n
                                                                                                                    • Scrumhow (?) (1)<\/li>\n
                                                                                                                    • Skype (1)<\/li>\n
                                                                                                                    • SnagIt (1)<\/li>\n
                                                                                                                    • SQL (1)<\/li>\n
                                                                                                                    • Tableau (1)<\/li>\n
                                                                                                                    • Visible Analyst (1)<\/li>\n
                                                                                                                    • Visual Studio (1)<\/li>\n
                                                                                                                    • Visual Studio Team Server (1)<\/li>\n
                                                                                                                    • Vocera EVA (1)<\/li>\n<\/ul>\n

                                                                                                                      Name three non-software techniques you use most.<\/span><\/p>\n

                                                                                                                        \n
                                                                                                                      • interviews (4)<\/li>\n
                                                                                                                      • communication (3)<\/li>\n
                                                                                                                      • brainstorming (2)<\/li>\n
                                                                                                                      • meetings (2)<\/li>\n
                                                                                                                      • process mapping (2)<\/li>\n
                                                                                                                      • prototyping (2)<\/li>\n
                                                                                                                      • relationship building (2)<\/li>\n
                                                                                                                      • surveys (2)<\/li>\n
                                                                                                                      • wireframing (2)<\/li>\n
                                                                                                                      • “play package” (1)<\/li>\n
                                                                                                                      • 1-on-1 meetings to elicit requirements (1)<\/li>\n
                                                                                                                      • active listening (1)<\/li>\n
                                                                                                                      • analysis (1)<\/li>\n
                                                                                                                      • analyze audience (1)<\/li>\n
                                                                                                                      • apply knowledge of psychology to figure out how to approach the various personalities (1)<\/li>\n
                                                                                                                      • business process analysis (1)<\/li>\n
                                                                                                                      • business process modeling (1)<\/li>\n
                                                                                                                      • calculator (1)<\/li>\n
                                                                                                                      • change management (1)<\/li>\n
                                                                                                                      • charting on whiteboard (1)<\/li>\n
                                                                                                                      • coffees with customers (1)<\/li>\n
                                                                                                                      • coffees with teams (1)<\/li>\n
                                                                                                                      • collaboration (1)<\/li>\n
                                                                                                                      • conference calls (1)<\/li>\n
                                                                                                                      • conflict resolution and team building (1)<\/li>\n
                                                                                                                      • costing out the requests (1)<\/li>\n
                                                                                                                      • critical questioning (1)<\/li>\n
                                                                                                                      • critical questioning (ask why fiive times), funnel questioning (1)<\/li>\n
                                                                                                                      • data analysis (1)<\/li>\n
                                                                                                                      • data modeling (1)<\/li>\n
                                                                                                                      • decomposition (1)<\/li>\n
                                                                                                                      • design thinking (1)<\/li>\n
                                                                                                                      • develop scenarios (1)<\/li>\n
                                                                                                                      • development efforts (1)<\/li>\n
                                                                                                                      • diagramming\/modeling (1)<\/li>\n
                                                                                                                      • document analysis (1)<\/li>\n
                                                                                                                      • documentation (1)<\/li>\n
                                                                                                                      • documenting notes\/decisions (1)<\/li>\n
                                                                                                                      • drinking (1)<\/li>\n
                                                                                                                      • elicitation (1)<\/li>\n
                                                                                                                      • expectation level setting (1)<\/li>\n
                                                                                                                      • face-to-face technique (1)<\/li>\n
                                                                                                                      • facilitiation (1)<\/li>\n
                                                                                                                      • fishbone diagram (1)<\/li>\n
                                                                                                                      • Five Whys (1)<\/li>\n
                                                                                                                      • focus groups (1)<\/li>\n
                                                                                                                      • handwritten note-taking (1)<\/li>\n
                                                                                                                      • hermeneutics \/ interpretation of text (1)<\/li>\n
                                                                                                                      • impact analysis (1)<\/li>\n
                                                                                                                      • individual meetings (1)<\/li>\n
                                                                                                                      • informal planning poker (1)<\/li>\n
                                                                                                                      • initial mockups \/ sketches (1)<\/li>\n
                                                                                                                      • interview (1)<\/li>\n
                                                                                                                      • interview end user (1)<\/li>\n
                                                                                                                      • interview stakeholders (1)<\/li>\n
                                                                                                                      • interview users (1)<\/li>\n
                                                                                                                      • interviewing (1)<\/li>\n
                                                                                                                      • JAD sessions (Joint Application Development Sessions) (1)<\/li>\n
                                                                                                                      • job shadowing (1)<\/li>\n
                                                                                                                      • listening (1)<\/li>\n
                                                                                                                      • lists (1)<\/li>\n
                                                                                                                      • meeting facilitation (prepare an agenda, define goals, manage time wisely, ensure notes are taken and action items documented) (1)<\/li>\n
                                                                                                                      • mind mapping (1)<\/li>\n
                                                                                                                      • notes (1)<\/li>\n
                                                                                                                      • note-taking (1)<\/li>\n
                                                                                                                      • observation (1)<\/li>\n
                                                                                                                      • organize (1)<\/li>\n
                                                                                                                      • paper (1)<\/li>\n
                                                                                                                      • paper easels (1)<\/li>\n
                                                                                                                      • pen and paper (1)<\/li>\n
                                                                                                                      • phone calls and fate-to-face meetings (1)<\/li>\n
                                                                                                                      • Post-It notes (Any time of planning or breaking down of a subject, I use different colored Post-Its, writing with a Sharpie, on the wall. This allows me to physically see an idea from any distance. I can also move and categorize at will. When done, take a picture.) (1)<\/li>\n
                                                                                                                      • prioritization (MOSCOW) (1)<\/li>\n
                                                                                                                      • process decomposition (1)<\/li>\n
                                                                                                                      • process design (1)<\/li>\n
                                                                                                                      • process flow diagrams (1)<\/li>\n
                                                                                                                      • process modeling (1)<\/li>\n
                                                                                                                      • product vision canvas (1)<\/li>\n
                                                                                                                      • prototyping (can be on paper) (1)<\/li>\n
                                                                                                                      • recognize what are objects (nouns) and actions (verbs) (1)<\/li>\n
                                                                                                                      • requirements elicitation (1)<\/li>\n
                                                                                                                      • requirements meetings (1)<\/li>\n
                                                                                                                      • requirements verification and validation (1)<\/li>\n
                                                                                                                      • requirements workshop (1)<\/li>\n
                                                                                                                      • responsibility x collaboration using index cards (1)<\/li>\n
                                                                                                                      • rewards (food, certificates) (1)<\/li>\n
                                                                                                                      • Scrum Ceremonies (1)<\/li>\n
                                                                                                                      • Scrums (1)<\/li>\n
                                                                                                                      • shadowing (1)<\/li>\n
                                                                                                                      • SIPOC (1)<\/li>\n
                                                                                                                      • sketching (1)<\/li>\n
                                                                                                                      • spreadsheets (1)<\/li>\n
                                                                                                                      • stakeholder analysis (1)<\/li>\n
                                                                                                                      • stakeholder engagement (1)<\/li>\n
                                                                                                                      • stakeholder engagement – visioning to execution and post-assessment (1)<\/li>\n
                                                                                                                      • stakeholder interviews (1)<\/li>\n
                                                                                                                      • swim lanes (1)<\/li>\n
                                                                                                                      • taking \/ getting feedback (1)<\/li>\n
                                                                                                                      • taking notes (1)<\/li>\n
                                                                                                                      • test application (1)<\/li>\n
                                                                                                                      • training needs analysis (1)<\/li>\n
                                                                                                                      • use paper models \/ process mapping (1)<\/li>\n
                                                                                                                      • user group sessions (1)<\/li>\n
                                                                                                                      • user stories (1)<\/li>\n
                                                                                                                      • visual modeling (1)<\/li>\n
                                                                                                                      • walking through client process (1)<\/li>\n
                                                                                                                      • whiteboard diagrams (1)<\/li>\n
                                                                                                                      • whiteboard workflows (1)<\/li>\n
                                                                                                                      • whiteboarding (1)<\/li>\n
                                                                                                                      • whiteboards (1)<\/li>\n
                                                                                                                      • workflows (1)<\/li>\n
                                                                                                                      • working out (1)<\/li>\n
                                                                                                                      • workshops (1)<\/li>\n<\/ul>\n

                                                                                                                        Name the goals of a couple of different projects (e.g., automate a manual process, interface to a new client, redesign screens, etc.)<\/span><\/p>\n