What would you do if you received a large task, 70% of which you know and know how to perform? How would you proceed?

First and foremost, I will break down the task into smaller and manageable subtasks using decomposition techniques.

For the known 70%:

• I will identify which parts of the task I already know and how to implement them.
• I will plan the steps to accomplish them, leveraging my knowledge and experience.
• I will automate processes where possible (building, testing, deployment).

For the remaining 30% of the unknown part:

• I will conduct research to acquire missing knowledge. I will study documentation, try to reproduce problems, and consult colleagues or the community.
• I may use prototyping or experiments to test hypotheses and find optimal solutions.
• I will schedule testing and debugging of these parts with special attention.

Throughout the process:

• I will apply Agile methodologies (such as Scrum or Kanban) for planning, execution, and progress tracking.
• I will maintain clear documentation at all stages.
• I will regularly communicate with the team and stakeholders, provide status reports, discuss issues, and make decisions.
• I will use version control systems (like Git) to manage changes in code and configurations.
• I will set up CI/CD pipelines for automating build, testing, and deployment, enabling quick feedback and minimizing risks.

An approximate action structure:

1. Task analysis: Fully understanding requirements, identifying known and unknown parts.
2. Decomposition: Breaking down into subtasks.
3. Planning: Defining steps, timelines, resources.
4. Implementation (known parts): Quick and efficient solutions using automation.
5. Research and implementation (unknown parts): Deep immersion, solution search, experiments, implementation.
6. Testing: Comprehensive testing of all parts of the task.
7. Deployment: Using CI/CD for safe and automated deployment.
8. Monitoring: Tracking the solution's performance post-deployment.

Example of CI/CD usage:

# Example pipeline in GitLab CI
stages:
  - build
  - test
  - deploy

build_job:
  stage: build
  script:
    - echo "Building the project..."
    # Commands for building, e.g., make build

test_job:
  stage: test
  script:
    - echo "Running tests..."
    # Commands for testing, e.g., pytest

deploy_job:
  stage: deploy
  script:
    - echo "Deploying the application..."
    # Commands for deployment, e.g., kubectl apply -f deployment.yaml
  only:
    - main # Deploy only from the main branch

This approach allows me to effectively utilize my strengths when working on known parts of the task and systematically address issues related to unknown aspects. It minimizes risks, accelerates the process, and ensures high quality of the final result.