sample.json

{
  "data": {
    "id": "37",
    "type": "evaluation",
    "attributes": {
      "candidate_name": "conrad mugisha",
      "candidate_email": "conrad.mugisha@gmail.com",
      "notes": null,
      "status": "evaluated",
      "score": "50.0",
      "summary": "Good understanding of web accessibility, performance optimization, API endpoints, code structure, and security. Has potential for growth in query construction, debugging slow queries, testing, monitoring, and estimation. Shows willingness to mentor junior developers and evaluate candidates. Demonstrates a solid plan for working with legacy software."
    },
    "relationships": {
      "interview_script": {
        "data": {
          "id": "110",
          "type": "interview_script"
        }
      },
      "answers": {
        "data": [
          {
            "id": "239",
            "type": "answer"
          },
          {
            "id": "245",
            "type": "answer"
          },
          {
            "id": "247",
            "type": "answer"
          },
          {
            "id": "248",
            "type": "answer"
          },
          {
            "id": "249",
            "type": "answer"
          },
          {
            "id": "251",
            "type": "answer"
          },
          {
            "id": "252",
            "type": "answer"
          },
          {
            "id": "244",
            "type": "answer"
          },
          {
            "id": "256",
            "type": "answer"
          },
          {
            "id": "257",
            "type": "answer"
          },
          {
            "id": "253",
            "type": "answer"
          },
          {
            "id": "254",
            "type": "answer"
          },
          {
            "id": "258",
            "type": "answer"
          },
          {
            "id": "240",
            "type": "answer"
          },
          {
            "id": "241",
            "type": "answer"
          },
          {
            "id": "243",
            "type": "answer"
          },
          {
            "id": "242",
            "type": "answer"
          },
          {
            "id": "246",
            "type": "answer"
          },
          {
            "id": "250",
            "type": "answer"
          },
          {
            "id": "255",
            "type": "answer"
          }
        ]
      }
    }
  },
  "included": [
    {
      "id": "110",
      "type": "interview_script",
      "attributes": {
        "name": "PHP, WordPress Developer assessment"
      }
    },
    {
      "id": "390",
      "type": "question_category",
      "attributes": {
        "name": "Front-End Advanced",
        "view_order": 2
      },
      "relationships": {
        "questions": {
          "data": [
            {
              "id": "1031",
              "type": "question"
            },
            {
              "id": "1032",
              "type": "question"
            },
            {
              "id": "1033",
              "type": "question"
            }
          ]
        }
      }
    },
    {
      "id": "3091",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of web accessibility understanding",
        "instruction": "- The candidate suggests implementing just a screen reader without considering other important accessibility measures.\n- The candidate demonstrates a lack of awareness or understanding of the need for web accessibility and the specific challenges faced by users with visual impairments.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1031",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3092",
      "type": "question_criterion",
      "attributes": {
        "description": "Semantic HTML for accessibility",
        "instruction": "- The candidate should mention the importance of using semantic HTML elements, such as headings, lists, and semantic tags (e.g., \u003cnav\u003e, \u003cmain\u003e, \u003cfooter\u003e), to structure the content and improve the accessibility of the website.\n- They should mention the need for providing descriptive alternative text (alt attribute) for images, ensuring that users with visual impairments can understand the content conveyed by the images.\n- An intermediate candidate may discuss the importance of maintaining sufficient color contrast between foreground and background elements to improve readability for users with visual impairments.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1031",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3093",
      "type": "question_criterion",
      "attributes": {
        "description": "ARIA attributes for accessibility",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should mention the use of ARIA (Accessible Rich Internet Applications) attributes, such as aria-label, aria-labelledby, and aria-describedby, to provide additional context and descriptions for elements that may not be adequately conveyed through visual cues.\n- An advanced candidate would discuss assigning appropriate roles to elements using ARIA roles, ensuring that assistive technologies can interpret and convey their purpose accurately.\n- They should highlight the importance of clear and visible focus indicators, such as outlines, for interactive elements to assist users navigating the site using keyboard or other assistive devices.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1031",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1031",
      "type": "question",
      "attributes": {
        "description": "Imagine that you are creating a website where 30% of users have some visual impairment, either partial or total. What precautions would you take to make your site more accessible?",
        "view_order": 16
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "390",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3091",
              "type": "question_criterion"
            },
            {
              "id": "3092",
              "type": "question_criterion"
            },
            {
              "id": "3093",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "239",
      "type": "answer",
      "attributes": {
        "transcription": "I would use audio cues in the website and.",
        "matched_criterion_reason": "The candidate suggests implementing just a screen reader without considering other important accessibility measures. The candidate demonstrates a lack of awareness or understanding of the need for web accessibility and the specific challenges faced by users with visual impairments.",
        "created_at": "2023-09-14T10:25:56.657Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBazBCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--01ee1affb6e719880f6df5241534b7982e6fdbf1/videoask_239_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1031",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3091",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "387",
      "type": "question_category",
      "attributes": {
        "name": "Back-End Fundamentals",
        "view_order": 3
      },
      "relationships": {
        "questions": {
          "data": [
            {
              "id": "1018",
              "type": "question"
            },
            {
              "id": "1020",
              "type": "question"
            },
            {
              "id": "1021",
              "type": "question"
            },
            {
              "id": "1022",
              "type": "question"
            },
            {
              "id": "1019",
              "type": "question"
            }
          ]
        }
      }
    },
    {
      "id": "3061",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of knowledge of SQL queries",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of SQL query building or the required concepts for solving the problem.\n- The candidate does not identify any relevant aspects or techniques needed to build the query.\n- The candidate fails to suggest any solutions or strategies to address the problem.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1021",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3062",
      "type": "question_criterion",
      "attributes": {
        "description": "Knows at least one Table joining, filtering, counting customers",
        "instruction": "- The candidate should recognize the need to join the products table with other relevant tables (such as customers and orders) to establish the necessary relationships.\n- The candidate should suggest using the LIKE operator in combination with the appropriate wildcard characters to filter products with names starting with the letter \"a\".\n- The candidate may propose using additional clauses or techniques (e.g., subqueries or grouping) to identify and count the distinct customers who have bought products meeting the \"a\" criteria.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1021",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3063",
      "type": "question_criterion",
      "attributes": {
        "description": "Knows table joining, count customers, filters using LIKE",
        "instruction": "- The candidate should recognize the need to join the appropriate tables (customers, products, and orders) to establish the relationship between customers and the products they have bought.\n- The candidate should demonstrate knowledge of functions such as COUNT, DISTINCT, and potentially other relevant functions to count the number of customers who have bought products starting with the letter \"a\" for each product.\n- The candidate should propose using the appropriate clauses (such as HAVING) to filter and identify the products whose names start with the letter \"a\". They should also mention using the LIKE operator with the appropriate pattern matching syntax to achieve this.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1021",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1021",
      "type": "question",
      "attributes": {
        "description": "Let's go down in our development stack, the relational database. In our database, we have a Customer table, a Product table, and an Order table with products bought by customers. The question is: how do you construct a query which counts how many customers bought products with the name starting with the letter A and by product? For this question, please don't provide the SQL, just the rationale behind your query construction.",
        "view_order": 5
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "387",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3061",
              "type": "question_criterion"
            },
            {
              "id": "3062",
              "type": "question_criterion"
            },
            {
              "id": "3063",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "245",
      "type": "answer",
      "attributes": {
        "transcription": "So in this case, we would select the count from orders from the orders table joined to the products joined to the products table through the product ID and also the customers table joined to the orders table through the customer ID, then group by the customer ID, where the criteria would be searching a product name like a with a wild card keynote. Yeah. So this would return the count with the count in the select field asterisk so that would return the count of the number of customers and.",
        "matched_criterion_reason": "The candidate recognizes the need to join the relevant tables (products, orders, customers) to establish relationships and suggests using the LIKE operator with wildcard characters to filter products. However, they miss some key aspects like counting customers by product and potentially using additional clauses or techniques.",
        "created_at": "2023-09-14T10:25:59.219Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbE1CIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--da5fbb04100ed69bf1a1842c4cb541cf413f4a82/videoask_245_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1021",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3062",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "388",
      "type": "question_category",
      "attributes": {
        "name": "Back-End Advanced",
        "view_order": 4
      },
      "relationships": {
        "questions": {
          "data": [
            {
              "id": "1023",
              "type": "question"
            },
            {
              "id": "1024",
              "type": "question"
            },
            {
              "id": "1025",
              "type": "question"
            }
          ]
        }
      }
    },
    {
      "id": "3067",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of knowledge of authentication and authorization",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of the concerns and best practices related to authentication and authorization in a web application.\n- The candidate does not identify any relevant concerns or potential security risks associated with authentication and authorization.\n- The candidate fails to suggest any solutions or strategies to address the security concerns related to authentication and authorization.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1023",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3068",
      "type": "question_criterion",
      "attributes": {
        "description": "Password encryption, session expiration, authorization checks",
        "instruction": "- The candidate should recognize the importance of encrypting passwords using appropriate encryption or hashing algorithms to protect user credentials in storage.\n- The candidate should mention the need to set session expiration mechanisms to automatically log out users after a period of inactivity or within a specific time frame.\n- The candidate should suggest ensuring that all sensitive operations or access points in the application are protected by proper authorization checks. They may mention the importance of validating user roles or permissions before executing critical actions.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1023",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3069",
      "type": "question_criterion",
      "attributes": {
        "description": "Knowledge of security policies: Authorization, CORS, passwords, advanced measures",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should be familiar with the concept of policy objects or similar approaches for fine-grained authorization control. They should explain how policies can define access rules and permissions for different user roles or groups within the system.\n- The candidate should mention the importance of configuring proper CORS policies to restrict cross-origin requests and mitigate potential security vulnerabilities.\n- The candidate should emphasize the significance of enforcing strong password policies to enhance authentication security. They should mention requirements such as minimum length, complexity, and potentially implementing password hashing techniques.\n- An advanced response may include suggestions for implementing additional security measures such as VPN (Virtual Private Network) access for administration users or IP restrictions to limit access to trusted networks or specific IP addresses.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1023",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1023",
      "type": "question",
      "attributes": {
        "description": "Every large e-commerce site has an Administration section where logged users from the company can operate the system. These sections must be secure. What concerns do you raise with authentication and authorization in web app? What can you do to make this app secure?",
        "view_order": 7
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "388",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3067",
              "type": "question_criterion"
            },
            {
              "id": "3068",
              "type": "question_criterion"
            },
            {
              "id": "3069",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "247",
      "type": "answer",
      "attributes": {
        "transcription": "You. In this case we would set up user roles on the system. This would be an example such as an admin staff role or a guest role. So in the event that one of the users could essentials is compromised, assuming it's staff, the damage that they would do on the system wouldn't be that much because there will be restrictions on each user role across the system because each role has a specific set of permissions so that kind of restricts the damage. And then the other bit would be in using authentication, authentication tools like would use JWTs. These are JavaScript web tokens. These generated when a user logs into a system, for example using an email or password, whatever credentials these are signed by the server and a token is sent back to the client. Now these can be used by the server to authenticate requests coming onto the server. Now if a token is invalid, access would be denied. So there are for securing the system and then there are also other libraries like OAuth that can be used to further secure the to steep.",
        "matched_criterion_reason": "The candidate recognizes the importance of user roles and permissions to limit the potential damage of compromised accounts. They also mention using JWTs for authentication and OAuth for additional security.",
        "created_at": "2023-09-14T10:26:00.224Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbFVCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--6ef78921f1779e86872e7884300f3b73e023b3f0/videoask_247_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1023",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3068",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3070",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of knowledge of testing practices",
        "instruction": "The candidate demonstrates a lack of knowledge or awareness of testing practices and their importance in software development.\nThe candidate does not mention any form of testing or does not consider it a necessary part of their development process.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1024",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3071",
      "type": "question_criterion",
      "attributes": {
        "description": "Unit testing, potential for growth in other levels",
        "instruction": "- The candidate should confirm their use of unit tests to verify individual code components. They should explain the benefits of unit testing in terms of identifying bugs early, ensuring code correctness, and facilitating future maintenance.\n- The candidate may primarily focus on unit testing without much experience in other testing levels. They may mention their willingness to learn and expand their testing practices to include other levels of testing, such as integration testing or E2E testing.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1024",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3072",
      "type": "question_criterion",
      "attributes": {
        "description": "Test automation, unit testing, advanced testing levels",
        "instruction": "- The candidate should confirm their use of test automation frameworks or tools to automate the execution of tests. They should explain the benefits of test automation, such as faster test execution, improved test coverage, and easier regression testing.\n- The candidate should mention their experience with writing and executing unit tests to verify the functionality of individual units of code, such as classes or functions. They should discuss the importance of unit testing for isolating and validating specific code components.\n- An advanced response may go beyond unit testing and include other levels of testing. The candidate may discuss their experience with integration testing, which verifies the interaction and compatibility between different components or modules. They may also mention E2E testing, which validates the entire system's behavior from end to end, and load testing, which assesses the system's performance under high loads or stress.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1024",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1024",
      "type": "question",
      "attributes": {
        "description": "Do you use test Automation in your projects? How do you test your code? What level of testing are you used to completing?",
        "view_order": 8
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "388",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3070",
              "type": "question_criterion"
            },
            {
              "id": "3071",
              "type": "question_criterion"
            },
            {
              "id": "3072",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "248",
      "type": "answer",
      "attributes": {
        "transcription": "Yes. I usually test for PHP. I use PHP unit to run my tests. And we use Travis CI for coverage. Covering coverage on the app? No, saco CI for coverage, Travis for the testing, CI CD process, or sometimes the GitHub workflows. Yeah, to fully test. Once the tests are successful, the app will be code onto the server. All the changes will be pulled to the server in case one of the tests fails. Then you'll be alerted and nothing your latest commits in the code won't be pushed to the server. Basically, I think that's how it works. It.",
        "matched_criterion_reason": "The candidate mentions the use of test automation (PHP unit) and a continuous integration tool (Travis CI) for testing their code. They also mention the process of not pushing changes to the server if a test fails. However, the candidate does not mention other levels of testing or explain the benefits of unit testing and test automation.",
        "created_at": "2023-09-14T10:26:00.769Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbFlCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--8b5c555aedd388b8fe66c1e6a02e8676c91fcc5e/videoask_248_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1024",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3071",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3073",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of testing awareness",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of testing practices and the importance of selective testing.\n- The candidate does not identify any specific areas or scenarios where testing may not be necessary or could be de-prioritized.\n- The candidate fails to suggest any strategies or guidelines for determining what should not be tested in an application.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1025",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3074",
      "type": "question_criterion",
      "attributes": {
        "description": "ORM integration, prioritized testing",
        "instruction": "- The candidate may mention that extensive testing of the ORM itself may not be necessary since it is a widely-used and well-tested technology. They should emphasize the importance of verifying the integration and interactions with the ORM rather than testing its internal mechanisms.\n- The candidate should recognize that proof-of-concept implementations, which are often temporary or experimental in nature, may not require the same level of rigorous testing as production-ready code. They should explain that the focus of testing should be on the final, stable version of the application.\n- The candidate may suggest that testing less important or low-risk code components can be de-emphasized to allocate more testing efforts to critical functionality. They should emphasize the importance of prioritizing testing based on the impact and risks associated with different parts of the application.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1025",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3075",
      "type": "question_criterion",
      "attributes": {
        "description": "Third-party library integration, prioritized testing",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- Advanced candidates understand that third-party libraries are typically extensively tested by their maintainers. These libraries often have their own testing processes and quality assurance practices. Therefore, it may not be necessary to perform thorough testing on the internal functionality of these libraries. Instead, the focus should be on verifying the integration of the application with these libraries and ensuring they work correctly within the specific context of the application.\n- Candidates with an advanced response recognize that not all functions or features within an application hold the same level of criticality. They understand that prioritizing testing efforts on the most important and high-risk areas of the application can be a more efficient use of resources. Less important functions, which have lower risks and lower impact on the overall system, may not require the same level of exhaustive testing. However, it is important to note that this doesn't mean completely ignoring these functions. Basic testing or sanity checks should still be performed to ensure they are functioning as expected.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1025",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1025",
      "type": "question",
      "attributes": {
        "description": "When and what do you not test in your application?",
        "view_order": 9
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "388",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3073",
              "type": "question_criterion"
            },
            {
              "id": "3074",
              "type": "question_criterion"
            },
            {
              "id": "3075",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "249",
      "type": "answer",
      "attributes": {
        "transcription": "Let's change components that have no impact in case something goes bad, in case they don't work or anything. For example? For example, if an image doesn't load or it oh, what? I wouldn't say relevant, irrelevant components on the app, but mostly, I think, some front end components. For example, like a footer. Not like a footer. I wouldn't write tests for a footer to load on the site. Doesn't seem to be a good use of my time. But I'm sure that they do write tests for front end components, but mostly only those that really crucial to the system and not these other small bits and.",
        "matched_criterion_reason": "The candidate demonstrates a lack of knowledge or awareness of testing practices and the importance of selective testing. They do not identify any specific areas or scenarios where testing may not be necessary or could be de-prioritized. They also fail to suggest any strategies or guidelines for determining what should not be tested in an application.",
        "created_at": "2023-09-14T10:26:01.215Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbGNCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--08a8e4e2f62da832d862317638155fd3380b3b5f/videoask_249_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1025",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3073",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "389",
      "type": "question_category",
      "attributes": {
        "name": "DevOps",
        "view_order": 5
      },
      "relationships": {
        "questions": {
          "data": [
            {
              "id": "1026",
              "type": "question"
            },
            {
              "id": "1027",
              "type": "question"
            },
            {
              "id": "1028",
              "type": "question"
            },
            {
              "id": "1029",
              "type": "question"
            },
            {
              "id": "1030",
              "type": "question"
            }
          ]
        }
      }
    },
    {
      "id": "3079",
      "type": "question_criterion",
      "attributes": {
        "description": "No knowledge of Babel \u0026 Webpack.",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of Babel and webpack and their purposes.\n- The candidate does not provide any relevant details or explanations regarding Babel and webpack and their usage in application setup.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1027",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3080",
      "type": "question_criterion",
      "attributes": {
        "description": "Babel: JS transpiler. Webpack: Asset bundler.",
        "instruction": "- The candidate should provide a basic understanding of Babel as a tool to transpile JavaScript code. They may mention its ability to convert modern JavaScript syntax into compatible versions for older browsers.\n- The candidate should demonstrate a general understanding of webpack as a module bundler. They may mention its role in bundling and optimizing various assets of an application.\n- The candidate may not provide a clear explanation of how Babel and webpack work together in the setup process.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1027",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3081",
      "type": "question_criterion",
      "attributes": {
        "description": "Babel: Transpile modern JS. Webpack: Bundle-optimized files.",
        "instruction": "- The candidate should provide a clear explanation of Babel as a transpiler. They should discuss how Babel allows developers to write modern JavaScript code (ES6/ES7/ESNext) and converts it into backward-compatible versions of JavaScript that can run in older browsers or environments. The candidate should mention the use of Babel presets and plugins to configure the specific transformations and polyfills needed for the project.\n- The candidate should explain webpack as a module bundler. They should describe how webpack takes all the project's modules, including JavaScript, CSS, and other assets, and bundles them together into optimized, production-ready files. The candidate should discuss the configuration of entry points, loaders, and plugins in webpack to handle different file types, perform transformations, and generate the final output bundle.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1027",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1027",
      "type": "question",
      "attributes": {
        "description": "Let's consider a situation where you are working on setting up an application. Could you explain how Babel and Webpack are used in the setup? What does each one do?",
        "view_order": 11
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "389",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3079",
              "type": "question_criterion"
            },
            {
              "id": "3080",
              "type": "question_criterion"
            },
            {
              "id": "3081",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "251",
      "type": "answer",
      "attributes": {
        "transcription": "From my experience, okay, from what I know, Babel is used to convert newer JavaScript, for example, like Es six, to an old version of JavaScript that can be that can be interpreted by most by all browsers or even old browsers, whereas Webpack is used in bundling bundles. The app. Yeah, bundling. And I think also opt minimizing the code.",
        "matched_criterion_reason": "The candidate demonstrates a general understanding of Babel and webpack, but lacks some details and explanations.",
        "created_at": "2023-09-14T10:26:02.195Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbGtCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--2e4aa728af8ca130d8d99ba160c920360323934b/videoask_251_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1027",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3080",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3082",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of knowledge on monitoring",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of monitoring practices and tools used in production environments.\n- The candidate does not provide any relevant details or explanations regarding monitoring approaches or incident detection in production.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1028",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3083",
      "type": "question_criterion",
      "attributes": {
        "description": "SaaS monitoring services mentioned",
        "instruction": "- The candidate may mention popular SaaS solutions such as New Relic, Rollbar, AppSignal, or other similar services. They should explain how these tools provide real-time monitoring, performance metrics, error tracking, and log analysis capabilities to detect failures and incidents.\n- The candidate should acknowledge the reliance on external services for monitoring and incident detection.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1028",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3084",
      "type": "question_criterion",
      "attributes": {
        "description": "Self-hosted monitoring \u0026 PagerDuty integration",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate may mention the option of using a self-hosted monitoring solution, where the organization sets up and maintains its own monitoring infrastructure. This could involve using tools like Prometheus, Grafana, ELK stack, or custom-built monitoring systems.\n- The candidate may highlight the use of PagerDuty, an incident management platform, to receive real-time alerts and notifications about failures and incidents in production. They should explain how PagerDuty integrates with various monitoring tools and provides on-call schedules and escalation policies for effective incident response.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1028",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1028",
      "type": "question",
      "attributes": {
        "description": "Your e-commerce is running in production. How do you monitor an app in production? How do you know about failures and incidents in production?",
        "view_order": 12
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "389",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3082",
              "type": "question_criterion"
            },
            {
              "id": "3083",
              "type": "question_criterion"
            },
            {
              "id": "3084",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "252",
      "type": "answer",
      "attributes": {
        "transcription": "You. So an app in production would basically check the logs. Man these are not one logs, but error logs, critical error logs. These would be logged. You'd enable this in your app. And also you would also check check would also check the status requests being sent. That is, if you have a panel and whatnot. But most importantly, checking logs helps you keep track of what's going on on the application. If it's running smoothly. For example, if it's a Web app, you check. If you're running, let's say, NGINX or Apache, you would be checking the error logs or the access logs for anything peculiar. Yeah.",
        "matched_criterion_reason": "The candidate demonstrates a lack of knowledge or awareness of monitoring practices and tools used in production environments. The candidate does not provide any relevant details or explanations regarding monitoring approaches or incident detection in production.",
        "created_at": "2023-09-14T10:26:02.618Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbG9CIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--d4a723ce64287e80f8590c637b26cd6dcfe559bf/videoask_252_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1028",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3082",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3058",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of knowledge of entity creation",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of the concerns associated with creating an entity through an API endpoint.\n- The candidate does not identify any concerns or potential issues that may arise when creating a new entity through an API.\n- The candidate fails to suggest any solutions or strategies to address the challenges associated with the creation of an entity.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1020",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3059",
      "type": "question_criterion",
      "attributes": {
        "description": "Authentication, validation and REST in API creation",
        "instruction": "- The candidate should recognize the importance of authentication and authorization mechanisms for the API endpoint. They should discuss the need to authenticate and authorize the request to ensure that only authorized users or clients can create a new product.\n- The candidate should suggest validating the payload sent to the API endpoint to ensure that it meets the required format and includes all the necessary data. They may mention the use of data validation techniques or frameworks to validate and sanitize the input.\n- The candidate may highlight the importance of adhering to RESTful principles. They should mention that the endpoint should use the HTTP POST method to create the product and return a unique identifier (e.g., the product ID) in the response to represent the newly created entity.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1020",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3060",
      "type": "question_criterion",
      "attributes": {
        "description": "Knows authentication, validation, REST, performance, testing in API creation",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should recognize that creating an entity through an API endpoint can have performance implications, especially if there are additional processes or validations involved. They should mention the need to optimize the endpoint's implementation to ensure it can handle a large number of requests efficiently.\n- The candidate should emphasize the importance of creating automated tests for the API endpoint that creates the product. They should discuss the need for unit tests and potentially integration tests to verify the correctness and reliability of the endpoint's functionality.\n- An advanced response may go beyond the basics and consider additional concerns such as data validation, error handling, transactional integrity, and potentially handling concurrent requests. The candidate may propose solutions or strategies to address these concerns.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1020",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1020",
      "type": "question",
      "attributes": {
        "description": "Now, you are going to create an API endpoint POST product, which creates a product with its data. Which concerns you must raise with an API endpoint that creates an entity? How would you solve them?",
        "view_order": 4
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "387",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3058",
              "type": "question_criterion"
            },
            {
              "id": "3059",
              "type": "question_criterion"
            },
            {
              "id": "3060",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "244",
      "type": "answer",
      "attributes": {
        "transcription": "First off, the attributes will be predefined, such as just giving an example title, price, cost, price quantity all these should be predefined before sending to the API. And the input has to be validated. It has to be cleaned. This is for security concerns to prevent like SQL injections and whatnot. And also to also make sure that the right input is going to be saved on this an entity in the database. Otherwise is it a 406? No. Invalid input response http response would be sent back to the client.",
        "matched_criterion_reason": "The candidate recognizes the importance of validating the input payload to prevent security issues and ensure the correct data is saved. They also mention the need for an appropriate HTTP response when the input is invalid.",
        "created_at": "2023-09-14T10:25:58.791Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbElCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--7eef0b2f2028ac89078adaf1d4c268abfc95983e/videoask_244_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1020",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3059",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "391",
      "type": "question_category",
      "attributes": {
        "name": "Project Management",
        "view_order": 6
      },
      "relationships": {
        "questions": {
          "data": [
            {
              "id": "1034",
              "type": "question"
            },
            {
              "id": "1035",
              "type": "question"
            },
            {
              "id": "1037",
              "type": "question"
            },
            {
              "id": "1036",
              "type": "question"
            }
          ]
        }
      }
    },
    {
      "id": "3103",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of experience in developer evaluation",
        "instruction": "- The candidate states that they have never interviewed a developer before or have not been involved in the evaluation process.\n- They do not provide any specific methods or criteria for evaluating whether a developer is a good fit for the company.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1035",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3104",
      "type": "question_criterion",
      "attributes": {
        "description": "Intuitive evaluation and technical interviews",
        "instruction": "- The candidate mentions considering their gut feeling or intuition when evaluating whether a developer is a good fit for the company.\n- They may mention conducting technical interviews, asking relevant questions about the candidate's experience and skills, and checking references.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1035",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3105",
      "type": "question_criterion",
      "attributes": {
        "description": "Structured interview process with evaluation criteria",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate mentions having an interview guide or a set of standardized questions and evaluation criteria to assess technical skills, cultural fit, and other relevant factors.\n- They describe a systematic approach to evaluating candidates, which may include assessing technical abilities through code testing, evaluating problem-solving skills, reviewing past projects, and conducting behavioral interviews.\n- The candidate emphasizes the importance of evaluating whether the developer's values, work ethic, and communication style align with the company culture.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1035",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1035",
      "type": "question",
      "attributes": {
        "description": "Have you ever interviewed a developer for yourself? How do you evaluate whether this developer is a good fit in your company?",
        "view_order": 21
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "391",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3103",
              "type": "question_criterion"
            },
            {
              "id": "3104",
              "type": "question_criterion"
            },
            {
              "id": "3105",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "256",
      "type": "answer",
      "attributes": {
        "transcription": "Most importantly would test the developer's problem solving ability then communication. Communication skills and how they interact with the team is important. Technical problem solving the experience and projects that they have worked on that they would bring this experience onto the projects that we're working on and their ability to communicate digest requirements from the project manager and translate these into usable into actual features on the system. I think that's most value the ball.",
        "matched_criterion_reason": "The candidate mentions assessing problem-solving abilities, communication skills, and previous experience to evaluate the fit of a developer. They also highlight the importance of translating requirements into features and working well with the team. They address technical skills, cultural fit, and relevant factors.",
        "created_at": "2023-09-14T10:26:05.206Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbDRCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--d90f1c8da5f6032b916ae0d03b3d258c39b63be0/videoask_256_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1035",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3105",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3106",
      "type": "question_criterion",
      "attributes": {
        "description": "Candidate gave a vague estimation, unclear justification",
        "instruction": "- The candidate provides vague or incomplete explanations of how they would estimate a project with unfamiliar technologies.\n- They may propose adding a significant amount of extra time to the estimation without a clear justification or reasoning.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1036",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3107",
      "type": "question_criterion",
      "attributes": {
        "description": "Candidate gave an experience-based estimation ",
        "instruction": "- The candidate mentions looking for projects with similar functionalities or requirements that they have previously worked on. They use these past experiences to estimate the effort and duration of the new project.\n- They rely on their existing knowledge of programming concepts, development methodologies, and project management practices to estimate the project. They may consider similarities in design patterns, database structures, or user interfaces.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1036",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3108",
      "type": "question_criterion",
      "attributes": {
        "description": "Candidate's response contains POCs, research, flexibility in its estimation",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate mentions conducting POCs or experiments to familiarize themselves with the new technology or framework. This allows them to assess its capabilities, potential challenges, and integration requirements.\n- They account for additional time needed to research and learn the new technology or framework before starting the project. This includes studying documentation, best practices, and seeking guidance from experienced developers.\n- The candidate acknowledges that the estimation might evolve as they gain more understanding and experience with the new technology. They emphasize the importance of flexibility and adjusting the schedule as needed.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1036",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1036",
      "type": "question",
      "attributes": {
        "description": "You received a new project which is well-defined with all screens in business rules. However, you must program it in a language and framework you have never worked with. Your boss requests an estimation of how long this project is going to take. How do you estimate projects with tasks and technologies that you have a lot of uncertainty or you have never worked with? For example, a new framework or a new language?",
        "view_order": 22
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "391",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3106",
              "type": "question_criterion"
            },
            {
              "id": "3107",
              "type": "question_criterion"
            },
            {
              "id": "3108",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "257",
      "type": "answer",
      "attributes": {
        "transcription": "In such a case, I would approximate the time it will take me to learn the new framework and the tools. So if it takes me two weeks to read the guides, the docs and everything, I would say the project would take me two weeks, take me a month. So multiply time was two, and that would be just a rough estimate. Usually it goes beyond, but when pressed with time, you would give yourself that room to make sure you build as fast as you can and test and ship. So if it's two weeks, if it's a month, four weeks, you could even add an extra week for testing. So you tell the boss to take you five weeks. That is, if everything checks out and, yeah, you don't stumble across the way and.",
        "matched_criterion_reason": "The candidate mentions relying on their existing knowledge and experience to estimate the project. They consider the time needed to learn the new framework and tools, but the justification provided is not clear and is based on rough estimates without specific reasoning.",
        "created_at": "2023-09-14T10:26:05.583Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbDhCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--15effb35b9bb79b84cd3b2b2f5b26b2abff356ae/videoask_257_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1036",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3107",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3085",
      "type": "question_criterion",
      "attributes": {
        "description": "Limited understanding of PR process",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of the PR process and its significance in a CI pipeline.\n- The candidate does not provide any relevant details or explanations regarding the essential or optional steps for approving a pull request.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1029",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3086",
      "type": "question_criterion",
      "attributes": {
        "description": "Code checks, peer review, collaboration",
        "instruction": "- The candidate should describe a process that includes necessary checks and validations before approving a PR. They may mention the importance of checking for code quality, linting, and adherence to coding standards.\n- An intermediate candidate would emphasize the involvement of peers or team members in reviewing and approving the PR. They should highlight the collaborative nature of the process, where feedback and suggestions are incorporated into the code changes.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1029",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3087",
      "type": "question_criterion",
      "attributes": {
        "description": "Structured PRs, comprehensive tests, code review, additional checks",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should mention the use of pull request templates or merge request templates to provide a consistent structure and guidance for creating PRs. They should explain how templates can include sections for description, purpose, impact, testing, and any other relevant information.\n- An advanced candidate would emphasize the importance of including tests as part of the PR approval process. They should discuss the need for comprehensive test coverage, including unit tests, integration tests, and any other relevant types of tests. The candidate should also highlight the requirement for the tests to pass successfully before approving the PR.\n- The candidate should discuss the significance of code review in the PR process. They should mention the involvement of peers or senior team members in reviewing the code changes, providing feedback, and ensuring adherence to coding standards, best practices, and architectural guidelines.\n- An advanced candidate may mention optional but valuable steps in the PR process, such as automated code analysis, security scanning, performance testing, and other relevant checks specific to the project or organization.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1029",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1029",
      "type": "question",
      "attributes": {
        "description": "You are responsible for creating a new project, a continuous integration pipeline, with a new team. How do you create a pull request process? What is essential and optional to approve a pull request?",
        "view_order": 13
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "389",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3085",
              "type": "question_criterion"
            },
            {
              "id": "3086",
              "type": "question_criterion"
            },
            {
              "id": "3087",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "253",
      "type": "answer",
      "attributes": {
        "transcription": "You. So, depending on the project settings, if the approver, the person in charge of the project has to review the code changes the commits made. Um, if there's something wrong in the code, he would decline that request the PR, and attach a comment. So the person responsible for pushing this, for requesting this PR would have to work on that fault and then make a new pull request. Now, if the approver, the owner of the project reviews the code and it checks out, he would approve the request and the pipeline will automatically pull this, will start running tests. Then if they pass to push to production, if one of the tests fails, and then that PR would be declined and the responsible parties would be notified by not emails or notifications on the system.",
        "matched_criterion_reason": "The candidate describes the essential steps for approving a pull request, but does not mention any optional steps.",
        "created_at": "2023-09-14T10:26:03.652Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbHNCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--628dc657bd3c95307b141cb28a642724540d07a1/videoask_253_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1029",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3086",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3088",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of Dockerfile knowledge",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of Docker image creation and the concerns to consider in a Dockerfile.\n- The candidate does not provide any relevant details or explanations related to Docker image creation or the concerns to address in a Dockerfile.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1030",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3089",
      "type": "question_criterion",
      "attributes": {
        "description": "Minimize image size and dependencies",
        "instruction": "- The candidate may mention the importance of using lightweight base images, such as Alpine Linux, to minimize the image size and reduce the attack surface.\n- An intermediate candidate would emphasize the need to install only the necessary dependencies and packages in the Dockerfile to keep the image size small and reduce potential vulnerabilities.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1030",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3090",
      "type": "question_criterion",
      "attributes": {
        "description": "Optimize Docker images for efficiency and security",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should mention the use of multi-stage builds in Dockerfile to optimize image size and reduce dependencies. They should explain how to separate build dependencies from the final runtime image.\n- An advanced candidate would highlight the importance of image compression techniques to minimize the size of Docker images. They may mention the use of techniques like squashing layers, using efficient base images, and leveraging tools like Docker's BuildKit to optimize the image size.\n- The candidate should discuss the importance of specifying a non-root user in the Dockerfile to enhance container security. They should explain how running containers with non-root users can mitigate certain security risks and follow the principle of least privilege.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1030",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1030",
      "type": "question",
      "attributes": {
        "description": "Are you used to creating images for Docker? What are the concerns you must raise in docker file?",
        "view_order": 14
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "389",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3088",
              "type": "question_criterion"
            },
            {
              "id": "3089",
              "type": "question_criterion"
            },
            {
              "id": "3090",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "254",
      "type": "answer",
      "attributes": {
        "transcription": "It, we would specify the image that we want to pull and specify some commands and install dependencies if needed. Yeah. And also cause specific ports for this image to be accessed by other services that would need them. For example, if this image was for a web server like NGINX, you'd have to expose a port like 80. Then 80 would be accessed by another service. Yeah. Bye.",
        "matched_criterion_reason": "The candidate mentions the need to install dependencies and specify ports in the Dockerfile, but the explanation is somewhat vague and lacks details.",
        "created_at": "2023-09-14T10:26:04.198Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbHdCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--21b38f151ae6d0addf0337a47977ff257f958774/videoask_254_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1030",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3089",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3109",
      "type": "question_criterion",
      "attributes": {
        "description": "Lacks interest in legacy code",
        "instruction": "- The candidate expresses a dislike or disinterest in working with legacy codebases.\n- They may show resistance to taking ownership of the project, especially given its outdated nature and lack of developer documentation.\n- The candidate does not propose any specific actions to address the outdated libraries, code quality, or testing concerns.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1037",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3110",
      "type": "question_criterion",
      "attributes": {
        "description": "Address bugs and make minimal changes",
        "instruction": "- The candidate acknowledges the need to address existing bugs and implement new features requested by stakeholders or users.\n- They plan to make minimal changes to the existing codebase to ensure that the software remains functional and stable. This approach aims to minimize the risk of introducing new issues or breaking existing functionality.\n- They might propose updating critical dependencies or libraries that are causing immediate problems but may not prioritize a comprehensive update of all outdated components.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1037",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3111",
      "type": "question_criterion",
      "attributes": {
        "description": "Update, refactor, test, document code",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate acknowledges the outdated libraries and plans to update them to the latest stable versions. They explain the importance of staying up to date with security patches, bug fixes, and new features.\n- They propose refactoring the codebase to improve its maintainability, readability, and performance. This may involve identifying and addressing code smells, removing deprecated features, and adhering to best practices.\n- The candidate emphasizes the need to establish or improve test coverage for the legacy codebase. They propose adding unit tests, integration tests, or automated regression tests to ensure the stability and correctness of the software.\n- They recognize the lack of documentation and the departure of the previous developer. They plan to document the codebase, architectural decisions, and known issues. They also consider sharing knowledge within the team through code reviews, pair programming, or knowledge-sharing sessions.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1037",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1037",
      "type": "question",
      "attributes": {
        "description": "You just received a legacy software in your favorite technology. However, this software is outdated by two years, the libraries are two versions old, and the last developer who worked on this project quit the company months ago. This software is now yours and you are responsible for developing some new features and also correcting some bugs. What is your plan to continue the software for the next six months?",
        "view_order": 23
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "391",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3109",
              "type": "question_criterion"
            },
            {
              "id": "3110",
              "type": "question_criterion"
            },
            {
              "id": "3111",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "258",
      "type": "answer",
      "attributes": {
        "transcription": "You. So the first step would be making a separate environment, a staging environment whereby I would upgrade this legacy system and check in case there are some modules that break. I'll try to patch those up, fix those bugs, and once done, then I can continue with building new modules, new features, because most of these updates are fixes to loopholes that were in the old system, such security patches or performance fixes. So upgrading would be a good choice. In the event that you can't upgrade. Then, for example, if there was a drastic change in versions and you stuck with that legacy version, then it's advisable to stay in that version, build features and I think also the method names and function calls, whatever you'd use for that version to prevent the system from breaking down and also run as many tests as possible during the six months.",
        "matched_criterion_reason": "The candidate acknowledges the outdated libraries and plans to update them to the latest stable versions. They explain the importance of staying up to date with security patches, bug fixes, and new features. They propose refactoring the codebase to improve its maintainability, readability, and performance. They emphasize the need to establish or improve test coverage for the legacy codebase. They recognize the lack of documentation and plan to document the codebase, architectural decisions, and known issues. They also consider sharing knowledge within the team through code reviews, pair programming, or knowledge-sharing sessions.",
        "created_at": "2023-09-14T10:26:06.124Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbUFCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--1cc485db61939353093aa8a6e54e77d0800c54a1/videoask_258_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1037",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3111",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3094",
      "type": "question_criterion",
      "attributes": {
        "description": "Lacks knowledge of load speed",
        "instruction": "- The candidate fails to provide any specific solutions or recommendations to reduce page load time.\n- The candidate demonstrates a lack of awareness or understanding of web performance optimization techniques and their impact on page load speed.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1032",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3095",
      "type": "question_criterion",
      "attributes": {
        "description": "Optimize assets for speed",
        "instruction": "- The candidate suggests compressing images and minifying CSS and JavaScript files to reduce their size and improve loading speed.\n- They may mention using appropriate cache control headers to enable browser caching of static assets and reduce the need for repeated downloads.\n- An intermediate candidate may discuss optimizing resource loading by deferring non-critical scripts, removing unnecessary dependencies, and using async/defer attributes appropriately.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1032",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3096",
      "type": "question_criterion",
      "attributes": {
        "description": "Deep expertise optimizing assets for speed",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should mention techniques like minifying and bundling CSS and JavaScript files to reduce their size and improve loading speed.\n- They should discuss the use of browser caching to store static assets locally and the utilization of CDNs to deliver content from servers closer to the user's location, reducing latency.\n- An advanced candidate would suggest implementing lazy loading techniques to defer the loading of non-critical resources until they are needed and code splitting to load only the necessary code for the current page or view.\n- They should mention techniques like optimizing images by compressing them without significant quality loss, using appropriate formats (e.g., WebP), and leveraging responsive images to serve different sizes based on the device's capabilities.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1032",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1032",
      "type": "question",
      "attributes": {
        "description": "You are working on an application that is slow to load on the user's web browser. What are three possible solutions to reduce the page load?",
        "view_order": 17
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "390",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3094",
              "type": "question_criterion"
            },
            {
              "id": "3095",
              "type": "question_criterion"
            },
            {
              "id": "3096",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "240",
      "type": "answer",
      "attributes": {
        "transcription": "I would use use caching cache frequently frequently made requests. Second would deactivate deactivate few unnecessary plugins running in the website. Three three I would let me see slow three caching deactivate plugins and three would be three would be checking the queries that are running in the background and editing them refactor basically on the queries, removing unnecessary joins and modifying the select return fields and.",
        "matched_criterion_reason": "The candidate suggests using caching to reduce the need for repeated downloads, deactivating unnecessary plugins to improve loading speed, and optimizing database queries for better performance. However, the answer lacks clarity and coherence, which affects the overall score.",
        "created_at": "2023-09-14T10:25:57.098Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBazRCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--ecd9ee020e6bbd680453b45350a07909774f4ba6/videoask_240_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1032",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3095",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3097",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of knowledge on reactivity",
        "instruction": "- The candidate demonstrates a lack of knowledge about reactivity in JavaScript frameworks and its purpose in modern web development.\n- They are unable to articulate the benefits of reactivity or provide an explanation of how it works in any framework.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1033",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3098",
      "type": "question_criterion",
      "attributes": {
        "description": "Explaining reactivity in frameworks",
        "instruction": "- The candidate should be able to explain the concept of reactivity in JavaScript frameworks, highlighting its benefits and how it enables automatic updating of the DOM.\n- While they may not have specific knowledge of reactivity implementation in a particular framework, they should be able to provide a high-level overview of how reactivity is achieved in general terms.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1033",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3099",
      "type": "question_criterion",
      "attributes": {
        "description": "Understanding framework reactivity is crucial",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should demonstrate a clear understanding of how reactivity is achieved in the chosen JavaScript framework, such as Vue.js or Angular.\n- They should be able to explain the specific mechanisms used for reactivity in the framework, such as watch functions in Vue.js or two-way data binding in Angular.\n- An advanced candidate may provide concrete examples of how reactivity works in real-world scenarios, demonstrating a comprehensive understanding of the concept.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1033",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1033",
      "type": "question",
      "attributes": {
        "description": "Could you explain how reactivity works on the chosen JavaScript framework?",
        "view_order": 19
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "390",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3097",
              "type": "question_criterion"
            },
            {
              "id": "3098",
              "type": "question_criterion"
            },
            {
              "id": "3099",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "241",
      "type": "answer",
      "attributes": {
        "transcription": "So reactivity in this sense, I would think it's referring to how the data changes in the application. So since no JavaScript framework has been mentioned here, I would assume like react. So this would refer to State, how state is handled in the app and how these values can be passed throughout the components in the application without refreshing or hard reloading the page.",
        "matched_criterion_reason": "The candidate provides a high-level overview of reactivity in JavaScript frameworks, mentioning state handling and passing values between components.",
        "created_at": "2023-09-14T10:25:57.386Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBazhCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--867d3ec0c033c742e38a4412d1b1b13d2ba696d9/videoask_241_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1033",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3098",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3055",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of knowledge on large lists",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of the concerns associated with handling large lists of items in an API endpoint.\n- The candidate does not identify any concerns or potential issues that may arise when dealing with large datasets.\n- The candidate fails to suggest any solutions or strategies to address the challenges associated with returning a large list of items.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1019",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3056",
      "type": "question_criterion",
      "attributes": {
        "description": "Performance and pagination for large datasets",
        "instruction": "- The candidate should acknowledge that returning a large list of items in a single payload can potentially have performance implications. They may discuss how handling and transmitting a large dataset can consume significant network bandwidth and increase response time.\n- The candidate should suggest using pagination as a solution to mitigate the performance impact. They may explain that the API endpoint should support pagination to split the large list into smaller, more manageable chunks that can be fetched incrementally. This approach allows clients to request and retrieve data in smaller portions as needed.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1019",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3057",
      "type": "question_criterion",
      "attributes": {
        "description": "Knows the importance of filtering, authentication, and access controls in API",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should recognize that searching or filtering functionality becomes important when dealing with a large list of items. They should mention that the API endpoint should support filtering based on various criteria (e.g., price range, category, keywords) to allow users to find specific products efficiently.\n- The candidate should emphasize the importance of authentication and authorization mechanisms for such an API endpoint. They should mention that appropriate access controls and user authentication should be implemented to ensure that only authorized users can access the endpoint and retrieve the product data.\n- The candidate should be aware that certain product data might be restricted or accessible only to specific user roles or permissions. They should discuss the need to handle sensitive or restricted information securely and ensure that the API endpoint enforces proper access controls to protect sensitive data.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1019",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1019",
      "type": "question",
      "attributes": {
        "description": "Let's consider e-commerce as a sample case to be used throughout the assessment. In this e-commerce, we have an API GET endpoint that provides a collection of products. It's a variable-sized list with products and their data. Which are the concerns you must raise with an API endpoint that returns a large list of items? How would you solve them?",
        "view_order": 3
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "387",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3055",
              "type": "question_criterion"
            },
            {
              "id": "3056",
              "type": "question_criterion"
            },
            {
              "id": "3057",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "243",
      "type": "answer",
      "attributes": {
        "transcription": "You. In this case, we'd set a default Pagination offset. This is to reduce the overhead on the server. If you have a large result set, it can have some performance implication especially on the server that is sending all this data. So if you have a default return set becomes easier so you can say the first 50 records or 1st 30 instead of everything that might slow might slow down the server in case there are 100 other clients making requests to this same endpoint.",
        "matched_criterion_reason": "The candidate acknowledges the potential performance implications of returning a large list of items and suggests using pagination as a solution",
        "created_at": "2023-09-14T10:25:58.391Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbEVCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--6808afcf689f41fa90792b4c2c77f78fa66f8279/videoask_243_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1019",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3056",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3052",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of understanding and low knowledge of software design",
        "instruction": "- The candidate fails to provide any meaningful benefits or suggestions for splitting a big class. They may not recognize the drawbacks of having a monolithic class or the advantages of splitting responsibilities.\n- The candidate indicates they don't know or have never encountered the situation before, showing a lack of experience or knowledge in software design best practices.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1018",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3053",
      "type": "question_criterion",
      "attributes": {
        "description": "Separate responsibilities, remove private methods",
        "instruction": "- The candidate acknowledges that splitting a big class into smaller, more focused objects can help improve maintainability and make the code easier to understand. They recognize that when a class becomes too large and starts to handle multiple responsibilities, it becomes harder to reason about and maintain. By separating responsibilities into different objects, the code becomes more modular and readable.\n- The candidate suggests removing private methods from the big class. They understand that private methods increase the complexity of the class and can make it harder to identify the class's responsibilities. By removing private methods, the code becomes more transparent and easier to understand. This can also improve testability since private methods are not directly accessible for unit testing, and testing through public methods may be more cumbersome.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1018",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3054",
      "type": "question_criterion",
      "attributes": {
        "description": "Also talk about SRP, cohesion, testability, split indicators",
        "instruction": "Beyond responses in 1 - Nice response,  the candidate responded one or more of the following possibilities:\n- The candidate should explain that the Single Responsibility Principle states that a class should have only one reason to change. They should discuss how splitting a big class into smaller, more focused classes can improve maintainability, modularity, and code reusability.\n- The candidate should mention that high cohesion within a class ensures that its methods and attributes are closely related and work together to fulfill a single responsibility. They should explain how splitting a big class into smaller classes can improve cohesion and make the code more organized and maintainable.\n- The candidate should discuss how splitting a big class into smaller, more focused classes can make unit testing easier. They should explain that smaller classes with fewer dependencies are easier to test in isolation, leading to more effective and efficient testing.\n- The candidate should demonstrate an understanding of the factors that indicate the need to split a big class into smaller projects. This includes recognizing situations where the class becomes too complex, tightly coupled, or violates SRP.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1018",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1018",
      "type": "question",
      "attributes": {
        "description": "Your project has a big class with lots of attributes, methods, and private methods. What are the benefits of these practices? And when should you split it up into two or more projects?",
        "view_order": 1
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "387",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3052",
              "type": "question_criterion"
            },
            {
              "id": "3053",
              "type": "question_criterion"
            },
            {
              "id": "3054",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "242",
      "type": "answer",
      "attributes": {
        "transcription": "Right? So this is basically Oop. So with Oop, it becomes easier to reuse some of these attributes and methods, and also debugging becomes easier, you know, which which method has a fault. And you can easily run tests and pinpoint where this problem is, and you can fix it. Now, in the event of splitting this splitting it into two projects would be if you're following the solid principle, the solid single responsibility principle, you would get you would look for separate the how can I say separate the requirements. So if the second project has to do with, let's say, book inventory, I'm imagining that the class is a big class, a library class. So if you have a book inventory, would probably split it and then kind of inherit the other class. I think, in my opinion, that's better.",
        "matched_criterion_reason": "The candidate demonstrates a good understanding of the benefits of splitting a big class and provides a valid reason for when to split it up into two or more projects.",
        "created_at": "2023-09-14T10:25:57.766Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbEFCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--d4bbd5881df87142c17fb3bd4980d8338fe3e1c2/videoask_242_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1018",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3054",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3064",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of knowledge of query optimization",
        "instruction": "- The candidate demonstrates a lack of knowledge or awareness of how to approach and solve performance issues related to slow queries.\n- The candidate does not identify any relevant aspects or techniques for diagnosing and optimizing slow queries.\n- The candidate fails to suggest any solutions or strategies to address the performance issue with the slow query.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1022",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3065",
      "type": "question_criterion",
      "attributes": {
        "description": "Query optimization, monitoring, indexes, join conditions",
        "instruction": "- The candidate should mention the use of database monitoring tools or query profiling tools to identify slow queries and gather performance metrics. They may propose analyzing query execution time, CPU usage, or I/O statistics to pinpoint potential bottlenecks.\n- The candidate should be aware of the n+1 problem, where multiple database queries are made within a loop or iterative process, leading to inefficient performance. They may suggest addressing this issue by optimizing the query to retrieve data in a single operation or by implementing query batching techniques.\n- The candidate should propose optimizing indexes based on the specific query and data access patterns. They may mention adding appropriate indexes or modifying existing indexes to improve query performance. They should explain that indexes help reduce the number of full table scans or unnecessary data retrieval.\n- The candidate should be able to identify cases where incorrect joins or join conditions can negatively impact query performance. They may suggest reviewing and optimizing the join logic or ensuring that appropriate join conditions are used.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1022",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3066",
      "type": "question_criterion",
      "attributes": {
        "description": "Knowledge on optimizing queries, indexes, and joins",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate should mention using the database's \"Explain query\" feature or similar tools to analyze the query execution plan. They should explain how this helps identify the steps taken by the database to execute the query and identify potential performance bottlenecks.\n- The candidate should recognize the possibility of optimizing the database schema by denormalizing tables or adding redundant data in specific scenarios. They should explain that denormalization can reduce the number of joins or improve data retrieval efficiency, thereby improving query performance.\n- An advanced response may go beyond the basics and include additional optimization techniques such as query rewriting, optimizing indexes, caching, or partitioning. The candidate may propose specific solutions or strategies based on the query and database context.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1022",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1022",
      "type": "question",
      "attributes": {
        "description": "Let's imagine a query that returns the list of products in apa from some questions ago. The problem is that you're facing a slow query. Is neither the browser nor the application, is the query. How do you debug a performance issue such as a slow query? What can cause slow queries? How do you solve them?",
        "view_order": 6
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "387",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3064",
              "type": "question_criterion"
            },
            {
              "id": "3065",
              "type": "question_criterion"
            },
            {
              "id": "3066",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "246",
      "type": "answer",
      "attributes": {
        "transcription": "You. So there are many ways to tackle this. The first being the first would be inspect the select fields, specify what fields we want to be returned in the select query. Another would be let on removing unnecessary joins in the queries. Also, in the case where we're trying to join heavy tables, these are tables with too many rows. We can use indexes we can index the table that will make the query performance faster. And then the other technique would be normalizing. So by normalizing is that we'd split a table into two. We'd have basically a mapping table that would have IDs pointing to another table. So when we're joining, it becomes quicker for the query to fetch data than pulling all this, than pulling than pulling everything from one large result set. Yes.",
        "matched_criterion_reason": "The candidate mentions some relevant aspects and techniques for diagnosing and optimizing slow queries, such as inspecting select fields, removing unnecessary joins, and using indexes. They also mention the concept of normalizing tables. However, there is room for improvement in terms of providing more details and additional techniques.",
        "created_at": "2023-09-14T10:25:59.623Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbFFCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--008045cd99d2161ad32c0df564b8926792ff1fe5/videoask_246_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1022",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3065",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3076",
      "type": "question_criterion",
      "attributes": {
        "description": "No understanding of server-side rendering",
        "instruction": "- The candidate demonstrates a lack of awareness or understanding of server-side rendering and its purpose.\n- The candidate does not provide any relevant details or explanations related to server-side rendering.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1026",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3077",
      "type": "question_criterion",
      "attributes": {
        "description": "Awareness of server-side rendering",
        "instruction": "- The candidate acknowledges the concept of server-side rendering but may not have hands-on experience working with it.\n- The candidate may provide a brief overview of what server-side rendering is but may not delve into the specific benefits or contexts in which it should be used.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1026",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3078",
      "type": "question_criterion",
      "attributes": {
        "description": "Hands-on experience with server-side rendering",
        "instruction": "- The candidate should demonstrate hands-on experience with implementing server-side rendering in projects.\n- An advanced candidate would be able to articulate the advantages of server-side rendering, such as improved search engine optimization (SEO) by providing pre-rendered HTML content to search engine crawlers, enhanced performance through faster initial page load times, and better accessibility and usability for users with slower internet connections or limited device capabilities.\n- The candidate should discuss the scenarios where server-side rendering is typically beneficial, such as content-heavy websites, e-commerce platforms with dynamic product listings, or applications that require good SEO performance.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1026",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1026",
      "type": "question",
      "attributes": {
        "description": "Have you ever used server-side rendering? Which context should be used?",
        "view_order": 10
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "389",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3076",
              "type": "question_criterion"
            },
            {
              "id": "3077",
              "type": "question_criterion"
            },
            {
              "id": "3078",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "250",
      "type": "answer",
      "attributes": {
        "transcription": "I haven't used server side rendering framework in production, but in experimentation and learning purposes I think I was using Next JS. And yeah, it helps in reducing the load on the client in loading data and stuff. So it helps the server handles, has the data and formulates its own data and the pages and sends this in the HTP response. Now, the response is then used by the client, thus reducing the client's load so making pages load faster. And it also boosts SEO search engine optimization for the search engines like indexing pages because that is basically a criteria for a site to get higher ranking on on search engines like Google, it has to load very fast. Now, if the server side returns pages in less than a microsecond. So that's kind of a boost and that's why I think they are becoming more popular in applications now.",
        "matched_criterion_reason": "The candidate acknowledges the concept of server-side rendering and its benefits, but does not provide specific details or examples.",
        "created_at": "2023-09-14T10:26:01.697Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbGdCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--41f63d1bbd9a1713d42217de5e805ca2318d0f5d/videoask_250_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1026",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3077",
            "type": "question_criterion"
          }
        }
      }
    },
    {
      "id": "3100",
      "type": "question_criterion",
      "attributes": {
        "description": "Lack of collaboration, no training plan",
        "instruction": "- The candidate expresses a strong dislike for pair programming or shows an unwillingness to engage in collaborative programming activities.\n- They do not provide any strategies or plans for training the junior developer, indicating a lack of consideration for their growth and development.",
        "grade": 0
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1034",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3101",
      "type": "question_criterion",
      "attributes": {
        "description": "Help on pair programming: sharing, mentoring",
        "instruction": "- The candidate demonstrates a willingness to share programming responsibilities with the junior developer, alternating turns during pair programming sessions.\n- They acknowledge the need to allocate specific time slots for training and mentoring, balancing it with their daily job responsibilities.",
        "grade": 1
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1034",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "3102",
      "type": "question_criterion",
      "attributes": {
        "description": "Helps junior developer training plan: guidance, independence",
        "instruction": "Beyond responses in 1 - Nice response, the candidate also mentions:\n- The candidate describes implementing a training program or plan for the junior developer, outlining specific areas of focus and progression.\n- They emphasize the importance of providing clear instructions and guidance to the junior developer during pair programming sessions, ensuring that tasks are broken down into manageable steps.\n- The candidate understands the need to allocate dedicated time for the junior developer to work independently, allowing them to practice and apply their skills while gradually increasing their autonomy.",
        "grade": 2
      },
      "relationships": {
        "question": {
          "data": {
            "id": "1034",
            "type": "question"
          }
        }
      }
    },
    {
      "id": "1034",
      "type": "question",
      "attributes": {
        "description": "You are going to pair programming with a very Junior developer. It's their first job as a developer. How do you conduct the pair programming and training? How do you train a new member while also managing your daily job?",
        "view_order": 20
      },
      "relationships": {
        "question_category": {
          "data": {
            "id": "391",
            "type": "question_category"
          }
        },
        "question_criteria": {
          "data": [
            {
              "id": "3100",
              "type": "question_criterion"
            },
            {
              "id": "3101",
              "type": "question_criterion"
            },
            {
              "id": "3102",
              "type": "question_criterion"
            }
          ]
        }
      }
    },
    {
      "id": "255",
      "type": "answer",
      "attributes": {
        "transcription": "In this case, I would assign I would assign law critical modules to be developed by the to be developed by the junior developer so such that they can get a hung of the code base and also our best practices so train them on the naming conventions, the deployment routines, how we review code. Yeah. So giving them non critical modules that they can experiment on and in the event that they say there are bugs and what I have to review as the trainer, I have to review the juniors code before I merge it into the main branch and ship to production. But yes, most importantly, give them less critical modules to work on and as in the process training them on naming conventions, deployment routines and how the flow is done at the present company.",
        "matched_criterion_reason": "The candidate demonstrates a willingness to share programming responsibilities with the junior developer, alternating turns during pair programming sessions. They acknowledge the need to allocate specific time slots for training and mentoring, balancing it with their daily job responsibilities.",
        "created_at": "2023-09-14T10:26:04.663Z",
        "media_url": "https://api.labs.revelo.com/rails/active_storage/blobs/redirect/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBbDBCIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--8281b26cea6d59e7816bcdff1a502e5613167d50/videoask_255_answer.mp3"
      },
      "relationships": {
        "evaluation": {
          "data": {
            "id": "37",
            "type": "evaluation"
          }
        },
        "question": {
          "data": {
            "id": "1034",
            "type": "question"
          }
        },
        "matched_criterion": {
          "data": {
            "id": "3101",
            "type": "question_criterion"
          }
        }
      }
    }
  ]
}