I've seen many companies that once used to follow plain old waterfall process claim to have switched to scrum and to be now doing agile development. But their software development process does not differ that much from what it used to be:
- Marketing/sales come up with an idea for a new feature
- They pass their ideas and requirements to a business analyst who works with them to create a detailed implementation plan
- The analyst passes the completed specification to the head of the development team
- The development head works together with the analyst and marketing/sales to clarify the requirements and implementation details
- The development head splits the task into parts and schedules them to be done at a certain short-length sprint (usually between 1 week and 1 month in length)
- When the sprint starts, developers are assigned individual tasks
- If necessary, developers communicate with analysts/marketing to clarify requirements (if at this stage requirements change so much that it becomes impossible to complete the feature within the current sprint, it is removed form the sprint and passed back to the analyst for clarification)
- When developers are done with all the tasks, a release candidate is assembled and passed to the QA team
- Testers are assigned to test individual tasks
- At the end of the sprint the QA-approved release candidate is published to production environment
- After publishing marketing/sales take a look at how the requested features were implemented and, if needed, come up with an improvement request that is again passed to the analyst, then to the dev head, etc.
Formally, this approach does no seem to contradict any agile manifesto points: the development team constantly communicate with customers (marketing/sales) to clarify their needs, they minimize risks of shipping the wrong product by making tasks small and getting feedback early (at the end of every sprint), they focus on delivering value instead of following rock-solid contract terms.
Yet, somehow this approach seems fishy. All agile/scrum tutorials suggest that much more changes should be made in order to be "fully agile": make the teams cross-functional, drop strict traditional manager/dev/QA roles, merge separate analyze-develop-test-deploy stages into a common workflow, etc.
My questions are:
- Does the development approach described above really not contradict any agile manifesto points? Are the companies utilizing it right in calling themselves "agile"?
- What benefits does going "full agile/scrum" bring compared to this approach?