Syllabus Evaluation & Skills Progression


In order to advance to Module 2, you are required to pass a summative assessment, coined the Pentathlon, conducted in week 6 of the module. Prior to that week, we’ll provide feedback regarding your skills through an individual mid-mock assessment in week 3, group project assessments throughout the six weeks, and any other opportunities including, but not limited to: 1-1 pairing, responses we’re seeing on weekly quizlettes, participation in class, progress in javascript foundations exercises, progress in static comp challenges.

In order to help you take ownership of your progression in the program and self-assess throughout the module, we’ve developed a Key Skills. The expectation for advancement to Module 2 is that a student is clearly “Proficient” across each key skill in every area of focus.


The legend below generally describes the developmental levels achievable during the six weeks of M1. The levels build off one another, whereby each increase assumes the expectations from the prior level were met.

Novice Can function but needs a lot of oversight.
Advanced Beginner Can function with very little oversight.
Proficient Can confidently implement code without the need for rigid feedback.
Exceptional Understands and executes advanced concepts.

For each of the subject matter areas of focus, we’ve applied these levels with added definition per key skill.



Novice Knows what a semantic tag is and leverages the HTML5 structural tags to organize the content of their markup.
Advanced Beginner Leverages more precise semantic tags when applicable, and employs basic ARIA roles attributes for added clarity in structure, descriptive image alt attributes, title attributes for applicable anchor tags.
Proficient Employs detailed accessibility practices throughout markup, especially in forms and can speak to decisions made in accessibility choices as it relates to specific accessibility concerns.
Exceptional Can run markup through a variety of online accessibility tools and score well for content, color, screen readers, etc.


Novice Crafts markup with proper indentation and opening/closing tags.
Advanced Beginner Crafts markup with proper and logical nesting.
Proficient Crafts lean, efficient markup that is easy to read and follow across naming conventions, structure, and solid formatting that follows industry best practices.
Exceptional Crafts lean, efficient markup and can speak directly to choices made to improve performance, including but not limited to, page load times, css/js optimizations, image optimizations.


Structure of Code

Novice Can effectively target DOM elements via tag, class, and/or id and write CSS rules around each element to create the desired style.
Advanced Beginner Can cleanly and logically organize CSS rules according to similar categories (i.e. typography, layout, components), and then logically organize the remaining CSS rules based on flow of the markup. Organizes properties within rules alphabetically.
Proficient Leverages cascading styles and CSS specificity rules to create more complex targeting of elements in order to reduce, reuse, share styles across elements. Organizes properties within rules based upon industry standard principles of writing consistent, idiomatic CSS.
Exceptional Understands the performance implications surrounding cascading/specificity and crafts CSS that is mindful of reducing complexity and increasing performance.


Novice Can articulate how the CSS box model works and apply it appropriately in a static layout.
Advanced Beginner Can articulate the differences between the approaches of absolute/relative positioning, flex-box, floats, and can appropriately apply the approaches to solve a variety of layout problems.
Proficient Develops layouts that work cross-browser, are responsive, and can logically defend the choices made in implementation approach for layout.
Exceptional Can articulate rationale for all parts of the CSS implementation (each line of code/CSS rule) specifically in regards to the balance of: structure of code, design integrity, performance.


Data Types

Novice Can articulate the definitions of primitive data types: strings, booleans, numbers, null, and undefined. Can articulate and describe object types: objects, arrays.
Advanced Beginner Can diagnose when issues of data-type mismatch are present and appropriately redirect their coding and/or research efforts accordingly to solve the problem.
Proficient Can identify and track data types through any variety of functions, understanding their affect and result on each line of code. Knows which scenarios are better suited for objects vs. arrays and employs them accordingly.
Exceptional Can assess and implement data type decisions for implementation based on increasing performance, shoring up code to be concise/clean, and composing for future maintainability.

Conditional Logic

Novice Can understand when an expression evaluates to true or false.
Advanced Beginner Uses if/else statements, but there are multiple levels of nesting, which makes the paths through the code difficult to follow. Understands what is “truthy” and “falsey” in JavaScript.
Proficient Can use an if/esle statement to effectively handle multiple paths through the code. Writes if/else statements that only have one level of logic (no nesting). Can use logical operators instead of if/else statements where applicable.
Exceptional Can write conditional logic that is succinct and easy to read. Logic can handle all situations where user gives incorrect/unexpected input.

Functions & Scope

Novice Can write a simple function that takes at least one input argument.
Advanced Beginner Developer is comfortable using multiple arguments to pass data into functions. Understands how variables are scoped at the function level and global level. Functions are named descriptively. Knows when and why to use return in a function.
Proficient Functions have single responsibility. The entirety of the function is easy to read what functionality it contains. Function is generally shorter than 8 lines. Uses functions to eliminate repeated code. Comfortable refactoring any piece of code and extracting it to a function.
Exceptional Comfortable with using callback functions where applicable. Comfortable returning collections from functions (objects, arrays).


Novice Can create array and use array indexing to extract data from array or modify array. Comfortable using arrays to store simple data types: numbers, booleans, or strings.
Advanced Beginner Can modify arrays by adding or removing specific elements - uses array methods such as push or shift. Can use a for loop to iterate through array.
Proficient Does not use for loops for arrays - uses array prototypes, such as forEach, to iterate through or manipulate arrays. Can use array to store more complicated data structures such as objects or nested arrays. Is comfortable/efficient with reading array prototype documentation and can efficiently test/apply array prototype methods they have not worked with before.
Exceptional Uses variety array prototypes to iterate through arrays and manipulate/create new arrays without using documentation as a resource.

Objects & Prototypes

Novice Can declare an object literal and define/articulate properties vs. methods for an object. Can extract values of an object’s property, and assign new properties and/or reassign values of existing properties on an object.
Advanced Beginner Can use object constructor functions and is comfortable with extracting values of properties on different object instances.
Proficient Can use object prototypes. Can articulate the definition and the “why” of an object prototype - the best use cases for prototypes.
Exceptional Can identify and apply best use cases for constructor functions vs object literals in their code, and leverages more advanced object prototype methods.

DOM Manipulation

Novice Can articulate what the DOM is and can effectively target elements in vanilla JavaScript via class, id, or tag.
Advanced Beginner Can add event listeners and create small functions that execute on events, can leverage the event object appropriately, and can articulate the what/why/how of jQuery.
Proficient Able to extract information, modify attributes, or append/prepend data in the DOM easily regardless of whether they are employing vanilla JavaScript or jQuery. Understands how to harness event bubbling.
Exceptional Understands the potential performance impact imposed by leveraging vanilla JavaScript vs. jQuery in their implementation and will make choices accordingly based on the problem to solve.


Novice Can explain the choices made in the overall codebase and is able to articulate what every line of code is doing. Code is neatly formatted and easy to read with correct indentation.
Advanced Beginner Code shows strong effort toward organization, but suffers from long functions, unnecessary or poorly named variables, and requires significant refactoring. Application may have some duplication and minor bugs.
Proficient Code is logically organized, such that reader can easily follow the progression of the app because variable and function names are descriptive and follow a single responsibility approach. There are no major bugs and minimal duplication.
Exceptional Application demonstrates excellent knowledge of JavaScript syntax, style, and refactoring. Application has exceptionally well-factored code with little or no duplication.



Novice Can use commits and can articulate what a commit is and why we use them. Makes large, infrequent commits directly to main branch.
Advanced Beginner Can create branches and willingly attempts to incorporate branches into their workflow. Commits, while infrequent, are increased in volume and show improvements in description.
Proficient Commits changes frequently with detailed commit messages. Uses feature branches to keep main branch free of incomplete features or bugs.
Exceptional Knows how to reset to previous commits, rebase large sets of small commits, if applicable, and other advanced Git maneuvers.


Novice Can articulate what GitHub is, how it is different from Git, and why it is important. Can comfortably push and/or pull changes from main.
Advanced Beginner Can execute basic pull requests with context about changes in description. Can keep local and GitHub repositories in sync.
Proficient Is comfortable with resolving merge conflicts. Asks for review/merge of their pull requests from teammates. Is comfortable editing code based on review feedback from a pull request and resubmitting the branch code.
Exceptional Uses issues as resource for project management. There are comments on specific lines of pull requests with discussion about the implementation.


Test Comprehension

Novice Can talk through the concept of testing and why it is useful.
Advanced Beginner Can read through a test and understand the structure. Can make the test pass, but takes a few attempts because developer does not use error messages effectively.
Proficient Can read through each line of a test and understand how to drive the development to make the test pass. If stuck on making a test pass, they know how to investigate where and how the test is failing using the error messages.
Exceptional Can write their own tests.


Comp Recreation

Novice Can establish a complementary color palette, integrate font(s), and execute a handful of the large comp details.
Advanced Beginner Can accomplish about 50-75% of the large and small design details and can logically rework them on at least 1 breakpoint.
Proficient Developer captures the spirit and design intent of the comp. Some small details need polish to achieve a pixel-perfect match to the comp, but developer is clearly mindful of details and has made a conscious and careful effort to match the comp. Any design decisions left open to interpretation are handled thoughtfully and are well executed, but are more noticeable and/or unintuitive than they would be if the designer had provided the solution, or may not be totally seamless during screen-size transitions.
Exceptional Developer skillfully captures the spirit and design intent of all comp details. Execution is pixel-perfect and any design decisions left open to interpretation are solved intentionally, are as seamless as if the designer had provided the solution, are handled gracefully, and enhance the overall design.

Design Concepts

Novice Can integrate typography, color choices, and layout in ways that do not detract from legibility.
Advanced Beginner Can apply fundamental design concepts with increased sensitivity that result in clear legibility but likely break in areas of responsiveness, layout, “noise”.
Proficient Can apply fundamental design concepts in a comp that demonstrates a thoughtful, purposeful, cohesive strategy that does not detract from legibility or overall design integrity.
Exceptional Typography, color choices, and layout decisions are thoughtful and appropriate, and strongly enhance the layout and legibility of the design.



Novice Can communicate needs, expectations, scheduling constraints through a DTR, effectively creating a working plan with partner.
Advanced Beginner Can identify deltas in skill level and collaborate on methods whereby both pairs can share equitably in the workload. Can revisit the DTR to address changes that arise, and/or simply to keep one another reminded of the working plan.
Proficient Can diplomatically handle issues that arise between the pair through respectful, focused, targeted feedback and implement changes to positively adapt the working relationship and keep the project on track. Can effectively implement tactics to support their partner’s learning and project goals, while also honoring their own personal learning and project goals, should the two be different or at different levels due to skill delta.
Exceptional Pair collaboration and communication is exceptional, with the distribution of work being equal and balanced, and both partners experiencing a good working flow, able to handle stress, deadlines, issues with calm and focused demeanor.


Dev Tools/Debug Process

Novice Reaches for the dev tools “Elements” pane to experiment and test variations for their HTML/CSS. Uses the “Console” pane in conjunction with their coding to test outputs of their JS at appropriate times.
Advanced Beginner Can articulate and leverage all the features of the “Elements - Styles” pane, including: find, edit html, state toggles, adding new elements/classes, and can read/track sections of the Elements-Styles pain (separated by grey dividers) back to their codebase.
Proficient Uses the dev tools as their first line of defense when encountering something unexpected. Demonstrates comfort and skill using dev tools to investigate, check layout issues, console log results, and experiment solving problems before writing abundant amounts of code. Will experiment with javascript in the console to test unfamiliar concepts.
Exceptional Is well versed in the Sources tab of the dev tools and can implement breakpoints, watch changing values of variables, and can work with debugger statements in place of console logs.

Technical Vocabulary

Novice Can articulate what is going on in the overall codebase. Doesn’t use the correct terminology.
Advanced Beginner Can articulate what is going on in the overall codebase and uses the correct terminology some of the time.
Proficient Can articulate what is going on in the codebase, line by line, using the correct terminology most of the time. Developer can speak to and answer questions that utilize technical vocabulary.
Exceptional Can articulate what is going on in the codebase, line by line, using the correct terminology. Developer is confident and comfortable speaking to and answering questions that utilize technical vocabulary.

Lesson Search Results

Showing top 10 results