<aside> 💡 During each Progress Review survey, apprentices are asked to share their progress against each of the KSBs.

</aside>

Outlined below are each of the KSBs and a non-exhaustive list of possible evidence to demonstrate each criteria.

Please be prepared to talk through your evidence for at least 1 knowledge, 1 skill and 1 behaviour at the Progress Review. The evidence can be via your portfolio, or other relevant documentation.

Knowledge

K1: All stages of the software development life-cycle (SDLC)

Draft and present a detailed SDLC plan for a new or existing project within the next month, identifying key stages, objectives, and timelines for each phase. This plan should be reviewed and feedback provided to deepen your understanding of the SDLC.
Create a case study document of a recent project (past three months), outlining how each stage of the SDLC was implemented, challenges faced, and solutions applied. Present this case study in a team meeting or a shared knowledge session by the end of the next quarter.
Host a workshop within the next two months for junior team members or peers focussing on a specific stage in the SDLC (e.g., testing or deployment) sharing best practices, tools, and techniques to enhance team skills in this area.

K2: Roles and responsibilities within the software development lifecycle

Interview members of your development team across different roles about their responsibilities in the SDLC. Compile this into a comprehensive guide on team roles and responsibilities within the SDLC, to be shared with the team and new starters within the next two months.
Lead a small project or a module of a larger project over the next three months, coordinating with team members across different roles. Document your experience, focusing on how understanding different roles impacted project execution, including lessons learned.
Organize a series of “day in the life” presentations within the next quarter, where team members from different roles (e.g., QA, Ops, Development) share insights into their daily tasks and their role in the SDLC, aiming to enhance cross-functional understanding among team members.

K3: The roles and responsibilities of the project life-cycle within your organisation

Create a detailed matrix contrasting the roles and responsibilities in the project lifecycle specifically within your organisation versus a standard SDLC model. Highlight unique practices and roles your organisation employs. Aim to complete and share this with your team for feedback within six weeks.
Propose and implement one improvement to your current project lifecycle based on best practices research. This could involve introducing a new tool, technique, or a role adjustment to increase efficiency or quality. Document the implementation and review its impact after three months.
Develop a mentorship plan to shadow different roles within your project cycle over the next three months, culminating in a presentation on how each contributes to the project's success and suggesting any potential improvements.

K4: How best to communicate using the different communication methods

Conduct a communication audit on your project over the next month, documenting the types of communication used (emails, meetings, chat), their effectiveness, and any areas of improvement. Present your findings and recommendations to your team.
Lead the implementation of a new communication tool or method within your team or project, based on audit findings. Oversee its adoption over three months, gather feedback, and create a report on its impact on project communication.
Create and deliver a workshop on effective communication techniques in software development projects, including the use of diagrams, concise writing, and active listening. Target to have this workshop ready and delivered within two months.

K5: The similarities and differences between different software development methodologies

Write a comparative analysis paper on Agile vs Waterfall methodologies, highlighting their similarities, differences, and ideal use cases. Aim to have this document peer-reviewed and publish it on your company’s knowledge base or a professional blog within six weeks.
Implement a pilot project using a methodology that is new to your team (if your team typically uses Agile, use Waterfall for a small project, or vice versa). Document the process, challenges, and outcomes of this pilot project and present your findings in a team meeting within the next three months.
Organize a panel discussion within the next quarter with project managers who have extensive experience in different methodologies. The goal is to provide insights and practical advice on selecting and implementing these methodologies effectively.

K6: Software design approaches and patterns

Contribute to an existing codebase by refactoring a module or feature using a design pattern that has not yet been adopted in the project but could improve scalability or maintainability. Document the before-and-after, and review the impact with your team within two months.
Host a code review session focusing on design patterns used in various parts of your project. Prepare by selecting examples from the codebase that illustrate successful use of design patterns. Aim to organize this session within the next six weeks.
Prepare and deliver a presentation on the importance of software design patterns, focusing on a couple of patterns that are highly relevant to your current project's challenges. Aim for this presentation to include practical examples and to be delivered at a team meeting within the next month.

K7: Organisational policies and procedures relating to the tasks

Develop a comprehensive checklist that aligns your organisation's policies and procedures with daily software development tasks. This checklist should be actionable and aimed to assist new team members in understanding these policies. Target completion within eight weeks.
Analyse and present a case study of a recent project where adhering to or overlooking specific organisational policies significantly impacted the project outcome. Include recommendations for future projects. Plan to have this ready for a team sharing session in three months.
Initiate and lead a policy review cycle for your development team focusing on data security and privacy policies. Collaborate with the compliance and legal team, aiming to identify any gaps or areas for improvement and propose adjustments within the next four months.

K8: Principles and uses of relational and non-relational databases

Design and implement a small project or module that utilizes both relational and non-relational databases, highlighting the use cases for each within the project. Document the design decisions, implementation challenges, and outcomes. Aim to complete this in three months.
Host a tech talk for your team or wider technical community comparing relational and non-relational databases, including performance benchmarks in specific use cases relevant to your work. Plan and deliver this talk within the next two months.
Write a blog post or internal documentation on optimising database queries, with examples from both relational and non-relational databases. Include best practices and common pitfalls. Aim to publish this within six weeks.

K9: Software testing frameworks and methodologies

Develop a comprehensive testing strategy document for an upcoming project, specifying the use of different testing frameworks and methodologies (unit testing, integration testing, etc.). Present this strategy to your team for feedback and implementation within two months.
Create and lead a testing boot camp for interested team members focusing on effective use of a new or underutilised testing framework within your technology stack. Plan for this boot camp to run over a week, with preparations starting immediately for execution within three months.
Conduct a comparative analysis of two testing frameworks suitable for your current project, ending with a recommendation and action plan for adopting the selected framework. Document your analysis and plan, aiming to present your findings to the team in six weeks.

K10: Develop effective user interfaces

Redesign an existing feature's user interface to improve usability based on user feedback or usability testing. Document your design process, user feedback, and implementation challenges. Review the impact of the redesign three months post-implementation.
Organise and conduct a user interface (UI) design workshop for your development team, focusing on principles of user-centric design and accessibility. Gather resources and examples relevant to your current projects. Aim to hold this workshop within the next two months.
Compile a UI guidelines document or a UI component library for your project or organisation, incorporating best practices for accessibility, responsiveness, and usability. Collaborate with designers and other developers, targeting a first draft within three months.

K11: Link code to data sets

Implement a feature that requires complex data handling, showcasing efficient data manipulation and linking techniques. Document the process, focusing on the choices made to ensure data integrity and performance. Present a post-mortem analysis of this implementation in a team meeting within two months.
Lead a knowledge-sharing session on effective data modelling and linking strategies for scalable applications. Prepare by researching current trends and best practices, including examples from your own work. Schedule this session to occur within the next six weeks.
Write and distribute a best practice guide on data handling for your team or organisation, focusing on security aspects, efficient data retrieval, and minimising data duplication. Collaborate with data scientists or database administrators if possible. Aim to complete this guide within three months.

K12: Communicate software solutions and ideas to technical and non-technical stakeholders

Prepare a detailed case study of a recent software solution you developed, aimed at a non-technical audience. Include problem definition, your approach, challenges faced, and the impact of the solution. Present this case study at an upcoming all-hands meeting within the next two months.
Develop and deliver a series of short webinars (3-4 sessions) on emerging technology trends relevant to your organisation's interests. Each webinar should cater to a different audience level, from technical to executive staff. Plan to start this series within three months.
Create a visual representation (e.g., infographic) of the architecture of a recent project, aimed at helping non-technical stakeholders understand the complexity and components of the system. Distribute this infographic in a company newsletter or during a project debrief session within six weeks.

Skills

S1: Create logical and maintainable code

Refactor an existing project module to enhance readability and performance. Document before and after metrics (e.g., lines of code, execution time) to review improvements.
Implement a new feature in an ongoing project using Test-Driven Development (TDD). Document the tests written and how they guided the feature development.
Contribute to an open-source project by selecting an issue to work on, submitting a pull request, and tracking its acceptance. Summarize the experience and feedback received.

S2: Develop effective user interfaces

Redesign a user interface component of a current project focusing on improving user experience based on user feedback or usability testing.
Build a responsive landing page from a provided design mockup, using modern CSS frameworks and principles. Test the page on multiple devices and document the responsiveness.
Implement an accessibility audit on a web application, document found issues, and improve at least three accessibility concerns. Share the before and after contrast ratios, keyboard navigability, and screen reader friendliness.

S4: Test code and analyse results to correct errors found using unit testing

Introduce unit testing into a project that lacks it, covering core functionalities. Document the testing coverage achieved and any bugs discovered and fixed.
Organize a code review session with peers focusing on improving test cases and coverage. Document the learned testing strategies and the outcomes of the session.
Set up Continuous Integration (CI) for an existing project to run unit tests on every commit. Document the CI tool setup process and how it's helped identify issues earlier.

S5: Conduct a range of test types

Lead a bug bash event with your team, focusing on finding and documenting bugs in a specific feature or module. Summarize the types of bugs found and the subsequent fixes.
Implement integration testing for a series of dependent components or services in your project. Document the integration points tested and issues identified and resolved.
Coordinate a user acceptance testing (UAT) session with actual or potential users of your project. Gather feedback through questionnaires and implement necessary changes based on the insights gathered.

S6: Identify and create test scenarios

Develop a comprehensive test plan for a new feature, outlining various test cases, expected outcomes, and edge cases. Review the test execution results and document the findings.
Create a series of automated end-to-end tests for a critical user flow in your application. Document the tools and frameworks used, and the impact of automation on testing efficiency.
Design a stress testing routine for an application's backend to understand its limits. Document the setup, the process, the metrics monitored, and the outcomes of the stress test.

S7: Apply structured techniques to problem-solving, debug code, and understand the structure of programmes

Host a problem-solving workshop focusing on debugging techniques with your apprenticeship group. Share a complex bug you encountered, how you approached fixing it, and the tools used.
Document a case study of a challenging programming problem you solved, focusing on the structured approach you took to break down and solve the problem.
Create and share a debugging guide for beginners based on your most frequent bugs and how you resolved them. Include examples, tools, and tips for efficient debugging.

S8: Create simple software designs to effectively communicate understanding of the program

Design a new software module using UML diagrams and present the design to your team or mentor for feedback. Document the design process and any iterations based on the feedback received.
Organize a design review session where you present the architectural choices of your personal project or a work project. Document the feedback and changes made as a result.
Create a technical blog post that explains a specific software design pattern by implementing a small project that showcases the pattern. Share the rationale behind the design choice and how it solves a common problem.

S9: Create analysis artefacts

Develop user personas and journey maps for an existing or hypothetical project. Share how these artefacts have influenced the design and development decisions.
Create and present a case study of a feature development from concept to deployment, focusing on the analysis phase and how user feedback was incorporated.
Conduct a competitive analysis of similar tools or products in the market, document your findings, and suggest improvements for your project based on the analysis.

S10: Build, manage and deploy code into the relevant environment

Automate the build and deployment process for a project using a CI/CD pipeline. Document the tools used, steps taken, and the impact on deployment frequency and stability.
Host a learning session on containerization (e.g., using Docker) for a project, including the creation of Dockerfiles and managing containers for development and production environments.
Set up a new staging environment for a project, documenting the process, and establishing deployment best practices. Organize a team walkthrough to familiarize everyone with the workflow.

S11: Apply an appropriate software development approach according to the relevant paradigm

Lead a transition or introduction of a new development methodology (e.g., Agile, Scrum) in your team. Document the process, challenges, and the outcomes observed.
Prepare a comparison report on two software development paradigms you experimented with during a project. Highlight the pros and cons of each and your recommendation.
Create a mini-series of blog posts or videos explaining a specific development paradigm. Use a project to illustrate the principles, practices, and outcomes of adopting such an approach.

S12: Follow software designs and functional or technical specifications

Design and implement a new feature, following a specific design and technical specification document. Document the adherence and any deviations from the initial design/specification.
Organize a specification review meeting for an upcoming project with your team. Document the feedback loop and the final agreed-upon specifications.
Write a technical specification document for a feature in an existing or hypothetical project. Later, implement the feature as specified and document any challenges and resolutions.

S13: Follow testing frameworks and methodologies

Implement a new testing framework within your project not previously utilized. Document the selection process, integration challenges, and the benefits it brings to the quality assurance process.
Host a workshop on advanced testing techniques that aren't widely used in your team (e.g., mutation testing, property-based testing). Share insights and how these can improve project testing.