Tasks and Duties
Task Objective: In this task, you will create a comprehensive design document for a Springboot application project. You will outline the application architecture, functionalities, API endpoints, and user journeys. This document will serve as your project's blueprint and will demonstrate your ability to plan and strategize before beginning code implementation.
Expected Deliverables: A single file (PDF or DOCX) containing the detailed design document. Your document should include a project overview, functional requirements, system architecture diagrams, data flow diagrams, and a schedule for implementation phases.
Key Steps:
1. Identify a project idea suitable for a Springboot application, such as a simplified user management or inventory system.
2. Conduct a requirements analysis based on your chosen idea.
3. Define key functional and non-functional requirements.
4. Create system design artifacts including architecture diagrams, database design sketches, and API endpoint summaries.
5. Outline your development roadmap with milestones and deliverables for future work.
Evaluation Criteria: Your submission will be evaluated based on the clarity and completeness of the design, accuracy of your diagrams, logical flow in your planning, adherence to best practices in software design, and overall presentation. You are encouraged to use publicly available resources for best practices and modern design trends. The goal is to witness a clear, detailed plan that paves the way for the coding and debugging phases, demonstrating critical thinking and a strong methodology.
This task is designed to take between 30 to 35 hours, with emphasis on research and meticulous planning. It requires you to apply theoretical knowledge into a well-formulated strategy document that is essential for any professional Springboot development process.
Task Objective: This task requires you to develop a basic RESTful API using Springboot. You will implement CRUD (Create, Read, Update, Delete) functionalities for a simple domain, such as a product catalog or user management system. The goal is to give you hands-on experience in setting up a Springboot project, developing endpoints, and ensuring that each endpoint follows RESTful conventions.
Expected Deliverables: A Springboot project compressed into a single file (ZIP archive) containing the source code. Additionally, include a README file that explains how to run the application and test the endpoints.
Key Steps:
1. Set up a new Springboot project with the necessary dependencies (Spring Web, Spring Data JPA, etc.).
2. Design and implement the data model.
3. Develop RESTful endpoints for CRUD operations.
4. Write unit tests for each endpoint using JUnit or another testing framework.
5. Document your API endpoints and provide example HTTP requests/responses in the README file.
Evaluation Criteria: Your submission will be judged on code quality, proper use of Springboot conventions, the robustness of your RESTful API, successful implementation of CRUD operations, testing coverage, and documentation clarity. The project should run without errors and be easy to set up for evaluation. This task is expected to take you approximately 30 to 35 hours and requires practical coding, debugging, and testing work.
By completing this task, you will demonstrate your ability to go from project setup to a functioning REST API, reflecting foundational skills in Springboot development.
Task Objective: In this task, you will enhance your Springboot application by integrating an external public API and developing comprehensive automated tests. The objective is to ensure that your application can interact with third-party services, process data from these services, and is thoroughly tested using JUnit and integration tests.
Expected Deliverables: A ZIP file containing your updated Springboot project source code along with a detailed test report or documentation file (PDF or DOCX). Your code should showcase integration with at least one public API (for example, a weather API or a news API) and include unit tests as well as integration tests.
Key Steps:
1. Choose a public API and understand its integration requirements.
2. Update your Springboot application to call the public API, process, and display or store the returned data appropriately.
3. Implement comprehensive unit and integration tests that validate API interactions, handle edge cases, and ensure correct error handling.
4. Create documentation detailing the changes made, steps to test the integration locally, and examples of API responses verified by tests.
Evaluation Criteria: Your solution will be assessed based on accurate and efficient API integration, correctness of automated tests, code quality, and the comprehensiveness of your documentation. Your documentation should clearly explain the rationale behind key design decisions and describe how to interpret test results. The task expects the candidate to demonstrate not only the ability to integrate third-party services but also to ensure this code works reliably through automated testing practices.
This practical assignment requires approximately 30 to 35 hours of work, cementing your skill set in both Springboot development and modern testing strategies.
Task Objective: This task focuses on the critical skills of debugging and performance optimization in a Springboot application. You will work on identifying, documenting, and resolving performance bottlenecks and bugs within a provided Springboot project template. This exercise aims to test your analytical skills and your ability to improve both the functionality and performance of a software application.
Expected Deliverables: A ZIP archive containing your modified Springboot project along with a detailed report (PDF or DOCX) describing the issues encountered, the debugging process, and the performance improvements made. Your report should include before-and-after performance metrics and any challenges faced during the debugging process.
Key Steps:
1. Begin with a baseline performance analysis of the provided Springboot project.
2. Identify areas where the application could be experiencing delays or resource inefficiencies.
3. Implement debugging techniques using logging, breakpoints, and profiling tools.
4. Optimize the code, database queries, or caching mechanisms to improve performance.
5. Document all changes, including problem descriptions, methods used to identify issues, and quantifiable results achieved after optimization.
Evaluation Criteria: Your submission will be evaluated on the clarity of your report, the effectiveness of the debugging methods, the relevance of the performance improvements, and the quality of your code modifications. Expected evaluation parameters include measurable performance gains, detailed documentation of problem-solving techniques, and adherence to best practices in debugging and optimization. This task is intended to require between 30 to 35 hours of work, focusing on real-world debugging scenarios and demanding practical solutions.
Through this challenge, you will demonstrate your ability to systematically improve a Springboot application's performance and reliability, a vital skill for any professional developer.
Task Objective: In this task, your goal is to enhance the security posture of a Springboot application by implementing industry-standard security features and data protection measures. You will incorporate authentication using JWT (JSON Web Tokens) and role-based access control, as well as integrate secure data handling practices into an existing Springboot project.
Expected Deliverables: A ZIP file containing the complete Springboot project with implemented security features, accompanied by a detailed documentation file (PDF or DOCX) explaining how security has been implemented and tested. The documentation should include descriptions of implementation steps, configuration settings, and instructions to test secure endpoints.
Key Steps:
1. Set up JWT-based authentication in your Springboot project.
2. Define roles and permissions to secure various API endpoints.
3. Implement secure data handling measures such as data encryption, secure cookie handling, or CSRF protection mechanisms.
4. Create a testing guide to verify that secured endpoints are accessible only to authorized users, and describe the testing process in your documentation.
5. Ensure to handle common security vulnerabilities effectively by following best practices.
Evaluation Criteria: Your submission will be evaluated based on how completely and securely the security measures are implemented, the clarity of your documentation, and adherence to security best practices. You will be assessed on the proper configuration of JWT, role-based access control, and data protection measures, as well as on the demonstration of successful security tests. This task is estimated to require 30 to 35 hours of work, giving you the opportunity to apply advanced security practices in a practical environment.
The ability to integrate robust security measures is essential for any modern Springboot developer, and this task will help consolidate your skills in building secure and reliable applications.