Master the Essentials of UI Test Automation: Chapter Three

Real Life Guidelines that Deliver Results

You’re reading the third post in a series that’s intended to get you and your teams started on the path to success with your UI test automation projects:

1. Introduction
2. Before You Start
3. People (you are here)
4. Resources
5. Look before You Jump
6. Automation in the Real World
7. Improving Your Success

Important note: After its completion, this series will be gathered up, updated/polished and published as an eBook. We’ll also have a follow-on webinar to continue the discussion. Interested?

• Register to receive the eBook
• Watch the follow on webinar on-demand.

Chapter Three: People

As with everything else in software development, success comes through getting good people and giving them the tools they need to succeed. Lining up the right people for your successful project means finding ones with the right skills, or giving them time and support to grow those skills.

Getting or Growing the Right People

Please get this clear in your mind immediately: you can't take developers with no UI automation background and expect them to succeed at test automation without help. You can't take manual testers and expect them to succeed at test automation without help. You can't take non-testers, give them a fancy tool and expect them to succeed at test automation without a lot of help. Ensure you're setting your organization up for success by ensuring you're able to get or grow the right team members.

UI automation requires a specialized set of skills to be effective. Becoming adept at UI automation requires time and mindful practice. ("Mindful practice" is a term used for carefully chosen work/study/practice meant specifically to improve one's skills or knowledge. You can't just "go through the motions" and expect to improve. You need to dedicate yourself to improvement. Read more in Andy Hunt's Pragmatic Thinking and Learning.)

Keep in mind that it's not enough to simply learn UI automation skills—just as you want developers who write great maintainable code, you also want people who understand how to write great maintainable automation scripts.

Finding great people in any corner of the software development domain is hard; finding people with great UI automation skills is much harder. It's a specialty that's underappreciated and not practiced widely enough. Make sure you have your time frame and budget expectations properly set if you're looking to expand your team by hiring.

What I've found more effective in my experience is to find current team members, or people elsewhere in my organization, and bring them to my team, then develop their skills. Poaching from other teams ("stealing" is such a harsh word!) can be politically tricky at times, so make sure you're not sawing off the branch you're standing on, metaphorically speaking.

Building UI Automation Skills

You'll need to work hard at building up your team's skills. This means you'll need both resources to learn from, plus a plan on how to learn.

Resources for Learning

Thankfully, there are a lot of great resources around to help you learn UI test automation. Better yet, many of the fundamental concepts are the same, regardless of the specific toolset you're working with, so you can look to industry experts rather than just tool experts.

Of course Telerik offers training specifics for Telerik Test Studio, but you can also look to some of these resources to help you build your domain-level knowledge of UI automation.

• Dave Haeffner's Elemental Selenium newsletter.
• Dave's The Internet project on GitHub and Heroku is a set of common automation problems like forms-based authentication, asynchronous actions, drag and drop and so on. It's great for learning fundamentals.
• Marcel de Vries' Pluralsight course on Coded UI (subscription required).
• Richard Bradshaw is prolific both on Twitter and his blog. His post on handling setup and configuration for WebDriver is full of great ideas.

Getting Your Team Learning

I've worked with many teams and individuals to help them up the learning curve, and I've talked with lots of other people who've been through the same process. All that experience and those conversations echo what should be common sense: directed, thoughtful practice is the best way to quickly get up to speed.

Remember: as you get to this point, it's critical that you've got support from stakeholders and your team. That support is key to getting through the learning process.

Here's an outline of a process that may be useful to you:

1. Find a guide: Look for someone with UI automation experience to help you and your team. Is there someone on a different team in your organization? See about getting them on your team, at least part-time. If not, hire an external guide to come in and help. Regardless of whether your guide is internal or external, this has to be a long-term commitment. You'll need more than a 2-day workshop; you'll need a relationship that will be highly involved for weeks, then ramp down over several months.
   
2. Make a plan: Lay out a roadmap for your team's learning experience. You'll need to think of things like general tool competency, creating backing APIs/helpers and, of course, creating the actual tests. Ensure all this work is in your backlog, work item tracker, Kanban board and so on. No training, skills building or actual automation work gets hidden!
   
3. Pair up: Pairing isn't just for developers. Pair less-adept team members with those who have more experience. You'll see benefits even if your team has no experience—putting two novices together, with frequent oversight and constant encouragement, can result in those two talking through problems and coming up with solid responses. (NOTE: This doesn't mean you can skip getting good guides for your team.)
   
4. Focus on value: You'll need to start with automation scripts that focus on small, "low-hanging fruit" features with which your team can be successful. That said, focus on scripts that will check honest business value for your stakeholders. Avoid wasting time on things like look and feel.
   
5. Trumpet successes: Make sure the team sees successes, especially as they're struggling to get up the learning curve. Figure out what metrics make sense to monitor for your team, and then get those up on a Big Visible Chart that everyone can see.
   
6. Share knowledge: Make sure that your team has the tools in place to share knowledge. Lessons learned, both positive and negative, are a huge help in the team's climb up the learning curve. Get some form of a knowledge base in place via Evernote, a wiki, or similar tools. Make sure it's easy to edit and search. Add "lunch and learn" brown bag sessions for the group to demonstrate concepts. Whatever you do, create the mindset that knowledge sharing isn't an option; it's expected.
   
7. Constant feedback: Software delivery benefits tremendously from constant feedback. Successful UI test automation projects, especially so. Prompt members to discuss automation during the teams' daily standup. Ensure your team retrospectives bring up good and bad points of your automation efforts. Most importantly, get stakeholder feedback on how they feel the effort is helping them: do the business owners feel they're getting better information to help them make informed decisions?
   

Your Team's Worth the Investment

Getting the right people lined up and empowered to succeed is crucial. Learning to master automation takes a long time, but the payoff is worth it: better value and higher-quality software delivered to your users.

Next in the series we'll talk about lining up the resources you'll need to be successful.

Are you enjoying this series so far and finding it useful? Let us know in the comments!