Coding for Schools. Simplified.
Kodable gives K-5 schools the tools they need to teach computer science successfully.
See it in actionYour all-in-one curriculum
Easy to follow lessons
70+ Lesson plans written for beginner teachers covering everything from Sequence to JavaScript.
Concept Tutorials
Videos explain new concepts before each unit.
Gamified Practice
Students practice new skills after each lesson with fuzzy aliens in space.
Monitor outcomes
Stay on track with CS standards and weekly updates.
Foster Creativity
Guide students from learning to think critically to creating new programs in JavaScript.
Learn more than code
Create a culture of learning that prepares students academically and personally.
Loved by Teachers
I am for the new lesson plans offered in the classrooms. They seem absolutely perfect for Kindergarten and I love that I will actually have some guidance to understanding and knowing how to teach coding! So stoked!
You'll see results throughout your school community
Fairfield-Suisan Unified School District created a culture of learning for their teachers and students.
Focus on technology or on integrated learning.
Kodable offers a 42 week scope and sequences. Teachers can also choose over 70 lesson plans covering subjects ranging from math and ELA to digital citizenship and JavaScript.
About the Computer Science Standards
Coding for schools, now with measurable student outcomes! The Kodable K-5 standards are a roadmap for developing the whole student through computer science. Our goal is to reach ALL students and see computer science become part of a complete elementary education.
Standards Team
Grant Smith - CSTA K-8 Task Force and Standards Review Committee
Grant trains K-8 teachers in computer science content and pedagogy. He also serves on the CSTA K-8 Task Force and Standards Review Committee. He is a former coding teacher and district administrator. Grant is also concurrently working on earning a doctorate from the Johns Hopkins University School of Education.
Brianna Gray - Kodable Head of Curriculum
Brianna taught Kindergarten for two years before joining Teach for America and continuing her teaching career. Brianna progressed from teaching to her current position at Kodable where she writes the Kodable curriculum and supports teachers, schools, and districts in teaching Computer Science. Brianna is passionate about education and opportunity for all children and her goal is that all students will have equal opportunity, tools, and support to learn Computer Science.
Rachel Brainerd - Teach for America Senior Managing Director of Institute
Rachel leads a staff to train and support ~250 novice teachers during their first weeks in the classroom. Partnering with several school districts to design and execute a rigorous summer school program for students, Rachel is focused on the intersections between teacher support and student learning. In her spare time, Rachel can be found hiking or playing her violin with an orchestra in Oakland, CA.
Jay Borenstein - Stanford University Computer Science Professor
Jay teaches Computer Science at Stanford University with a focus on Virtual Reality, Software Engineering and Entrepreneurship. Jay founded Integration Appliance in 2000 and served as the CEO through 2007. Jay also runs the “Education Modernization” (EdMod) group at Facebook. EdMod initiatives include Facebook inspirED, TechStart, VR Camp and Facebook Open Academy. Jay is also a Director at 6Seconds - The Emotional Intelligence Network. Jay studied both as an undergraduate and graduate student at Stanford University.
Brian Adams - Informational Technology Teacher
Brian teaches at a K-3 elementary school in Colonial School District (PA). In his 22-year career, he has taught second grade as well as Technology to K-3 students. In Technology, Brian’s students are developing a foundation of basic programming skills and concepts, working with robotics, and creating and designing using the engineering design process.
Computer Science Strands
Computational Thinking
Programming and Communication
Programming Impact
Social Emotional Learning
Everyday Connections
Programming and Me
How to Read the Standards
Single Grade Standards
Multiple Grade Standards
Kindergarten Computer Science Standards
Identify code as language people use to control machines.
1st Grade Computer Science Standards
Identify algorithms to complete a task and apply logic statements.
2nd Grade Computer Science Standards
Write, describe, apply and debug multiple coding concepts.
3rd Grade Computer Science Standards
Write, describe, and apply algorithms using multiple coding concepts.
4th Grade Computer Science Standards
Read and modify scripts to change what happens on the screen.
5th Grade Computer Science Standards
Read, modify, and write scripts that change what happens on the screen.
How to Read the Standards
Single Grade Standards
Multiple Grade Standards
| Computational Thinking and Programming Concepts | |
|---|---|
| CT.K.1 | Use numbers and symbols to represent data (e.g., thumbs up/down for yes/no, color by number, arrows for direction). |
| CT.K.2 | Identify and describe elements in a pattern. |
| CT.K.3 | Decompose a model or task into smaller elements. |
| CT.K.4 | Identify and describe an error (bug) when it is occurring (e.g., “The arrow should be pointing to the right here, not up.). |
| CT.K.5 | Select and test the appropriate solution to fix a bug when given multiple options. |
| CT.1.1A | Use numbers or other symbols to make a model representing a set of data. |
| CT.1.1B | Define code as a language for computers and recognize there is more than one computer language. |
| CT.1.2A | Decompose a problem into the variety of possible smaller problems, identifying patterns. |
| CT.1.2B | Describe characteristics of the problems in order to understand outcomes and restraints. |
| CT.1.3 | Create and arrange sequences of steps to reach a desired outcome. Use appropriate vocabulary (e.g., algorithm) to describe these steps. |
| CT.1.4 | Identify and describe an error when it is occurring (e.g., “The arrow should point up on the green tile, not down.”) within a larger script, involving additional programming elements such as conditions and loops. |
| CT.1.5 | Select and test the appropriate solution to solve a bug when given multiple options, with more complicated code structures. |
| CT.2.1 | Identify characteristics of code (length, characters, integers, different types). |
| CT.2.2 | Determine the best sequence based on a series of outcome restraints. Justify the choice. |
| CT.2.3 | Arrange a sequence of code in multiple ways to reach a single outcome. Choose the most efficient and provide rationale. |
| CT.2.4 | Predict the outcome of specific scripts, considering errors that may occur. |
| CT.2.5A | Automate solutions by using elements in code that increase efficiency, save time, and decrease the likelihood of bugs. |
| CT.2.5B | Test and refine automated solutions to determine maximum efficiency. |
| CT.3.1 | Demonstrate an understanding that code follows specific organization patterns. Accurately describe the way a complete set of data is organized (e.g., lists, grouping, types of data). |
| CT.3.2A | Identify and apply different programming elements to solve a problem (variables, conditions, loops, functions). |
| CT.3.2B | Decompose a real world problem into sub problems/smaller steps. |
| CT.3.2C | Decipher between problems that can and cannot be solved computationally. |
| CT.3.3 | Modify values within a script to change an isolated part of the outcome. |
| CT.3.4 | Identify and explain the source of a bug using the vocabulary of variables and sequences. |
| CT.3.5 | Identify opportunities within a program that can be manipulated to make something happen (e.g., When I click, this happens) |
| CT.3.6A | Classify different types of data used by a computer or program. |
| CT.3.6B | Sort groups of data into relevant and irrelevant based on specific criteria. |
| CT.3.7A | Identify, use, and modify information within a program. |
| CT.3.7B | Identify, apply, and explain rationale for the type of data, when it used, and where it is used within a program. |
| CT.3.7C | Identify and use tools to store and access data. |
| CT.4.1 | Identify syntax rules, grouping, naming, and other levels of organization. Justify personal rationale. |
| CT.4.2 | Identify a problem that can be solved computationally and formulate one possible multi-step solution. |
| CT.4.3 | Identify and describe the variables and values of given set of data. |
| CT.4.4 | Apply skills to accurately fix bugs that exist within a script. |
| CT.4.5 | Automate data organization and replicate results. |
| CT.4.6 | Translate information into code using different types of variables and justify rationale for this choice. |
| CT.5.1A | Organize code following syntax rules, grouping, naming, and other levels of organization. |
| CT.5.1B | Organize code with increasing detail and justify personal rationale. |
| CT.5.1C | Follow rules that specify how code should be organized with consistency. |
| CT.5.2 | Identify a problem that can be solved computationally and formulate multi-step solutions, selecting the best possible and explaining why. |
| CT.5.3 | Modify and revise variable values within a set of data to reach a desired outcome. |
| CT.5.4 | Identify and use tools that find and fix bugs within a script. |
| CT.5.5A | Modify data to change a specific outcome. |
| CT.5.5B | Compare and contrast the characteristics of similar objects. |
| CT.5.5C | Describe the relationship between efficiency and programming language paradigms. |
| CT.5.6 | Use variables to sort and store information. |
| CT.A.15 | Justify decisions by demonstrating an understanding of “if, then” statements. Students should be completing this at all grade levels, increasing complexity each year. |
| CT.B.K2 | Model processes and systems that satisfy “if, then” statements. Students should be completing this at all grade levels, increasing complexity each year. |
| CT.C.45 | Automate solutions by manipulating repeatable events within a program. |
| CT.C.35 | Define, identify, and apply variables within a program, including.
|
| CT.D.35 | Take actionable steps to satisfy “if, then” statements within a program, taking into account observations, events, and the relationships between objects and systems. |
| Programming and Me | |
|---|---|
| PM.K.1 | Cultivate habits in using technology in safe and correct ways. |
| PM.K.2 | Demonstrate an understanding of their role in making machines function. |
| PM.K.3A | Articulate the task they are asking the computer to do. |
| PM.K.3B | Describe the instructions they have been giving by articulating the steps. |
| PM.1.1 | Demonstrate an understanding of using secure measures on networks and the internet (e.g., passwords, personal devices). |
| PM.1.2 | Articulate the relationship between the programmer and the computer, the user and the computer, the role of instructions in these relationships. |
| PM.1.3 | Follow and give a set of instructions in order to complete a task. |
| PM.2.1A | Compare and contrast measures of security to determine level of safety (e.g., password strength). |
| PM.2.1B | Create secure measures for a personal computer or network that meet a level of high security. |
| PM.2.2 | Explain what will happen when a computer is given instruction. Demonstrate an understanding that computers follow directions given by programmers. |
| PM.2.3 | Compare and contrast sets of instructions (loop or no loop, function or no function) to determine the efficiency of obtaining the desired outcome (e.g., which will get me there faster? Which will save me time?) |
| PM.3.1 | Identify alternative measures of security for data, such as offline backups and virus software. |
| PM.3.2A | Describe differences between what a programmer sees and what the user sees within a program. |
| PM.3.2B | Describe the process of input and output using examples. |
| PM.3.3 | Accurately plan and design a set of instructions that will reach a desired outcome. |
| PM.4.1 | Define ownership and demonstrate an ability uphold copyright, fair use, and proper citations. |
| PM.4.2A | Explain the connection between variables and output of a program. |
| PM.4.2B | Modify the output of a program by adjusting the input. |
| PM.4.3 | Assign components of a project to multiple people, collectively implementing a set of instructions to reach a desired outcome. |
| PM.5.1 | Explain the role confidentiality has in online security. |
| PM.5.2 | Effect the output of a program by changing values. |
| PM.A.K5 | Demonstrate an understanding of using hardware and software in appropriate ways (eg., choosing the right tools, using the right vocabulary when describing hardware and software, etc.) |
| Programming Impact | |
|---|---|
| PI.K.1 | Identify problems that technology has solved in history and tools that were used to solve them. |
| PI.3.1A | Create realistic technological solutions for real-world problems. |
| PI.3.1B | Describe the usability of technological solutions for different groups of people. |
| PI.3.2 | Describe the positive and negative impacts programming has on the relationship between multiple parties or objects. |
| PI.3.3 | Describe the impact one person can have on another through programming and networks (e.g., cyber bullying). |
| PI.4.1 | Compare and contrast technological solutions for real-world problems based on the needs and desires of specific users (e.g., would this work for a mom? For someone who can't walk?) |
| PI.4.2 | Compare and contrast interactions and analyze the impact on others’ emotions. |
| PI.5.1 | Incorporate expressed ideas and needs from users to revise and modify technological solutions for real-world problems. |
| PI.5.2 | Apply constructive approaches to resolving conflicts through programs and networks. |
| PI.A.12 | Identify and describe problems that technology has solved in current events. |
| PI.B.K5 | Identify programming pioneers and understand their impact on the field. |
| PI.C.12 | Describe the work that people do within the field of computer science and identify specific jobs related to programming today. |
| PI.D.12 | Demonstrate an understanding of the role that programming can play in the environment, health, and people around the world. |
| PI.B.35 | Describe the work of people 0-25 years of age and the role they play in computer programming. |
| PI.C.45 | Demonstrate an understanding that working collaboratively is essential to developing technological solutions that meet the needs of all users. |
| Everyday Connections | |
|---|---|
| EC.K.1 | Demonstrate an understanding of why technology matters. |
| EC.K.2 | Demonstrate an understanding of routines and articulate the steps within daily routines (such as washing hands, tying shoes, routines within the school day). |
| EC.K.3 | Recognize programs as routines and connect daily routines to programming. |
| EC.1.1 | Identify and describe places in the school day or daily tasks where technology may provide a possible aid. |
| EC.1.2 | Demonstrate an understanding of the role instructions play within school day routines and within computer programming. |
| EC.1.3 | Compose, decompose, and sequence:
|
| EC.1.4 | Describe methods for organizing information and materials. |
| EC.2.1 | Create algorithms to represent and replace routines and procedures within the classroom (e.g., the sequence of the phrase “Criss-Cross Applesauce”). Explain the relationship between sequence and functions with routines and procedures. |
| EC.2.2 | Compose, decompose, and sequence elements in tasks that have repeatable elements (e.g., making 10 peanut butter and jelly sandwiches). |
| EC.2.3 | Compare and contrast methods for organizing information and materials in a classroom and on a computer. |
| EC.3.1 | Describe the characteristics of storage for different materials on a computer (i.e., files may be different sizes.) |
| EC.4.1 | Sort methods of organization based on the type of data one wants to store. |
| EC.5.1 | Accurately store, retrieve, and read files of various types. Describe the process and personal preference using appropriate vocabulary. |
| Programming and Communication | |
|---|---|
| PC.K.1 | Express personal opinion related to problem-solving. |
| PC.K.2 | Retell the steps followed to complete a task. |
| PC.1.1 | Describe and justify choices within a task, sequence, or algorithm. |
| PC.1.2 | Attribute ideas to the proper owner. |
| PC.2.1 | Explain communication as it relates to programming: people to machine, machine to machine. |
| PC.2.2 | Listen and think critically about someone else’s solution to the same problem. |
| PC.3.1 | Communicate steps and desired outcome using multiple methods to document (oral, written, representational). |
| PC.3.2 | Translate others' ideas into programming commands to reach a desired outcomes. |
| PC.4.1 | Explain real life interactions that happen in order to reach an outcome or solve a problem. |
| PC.4.2 | Expand and build on others' ideas to create more efficient programming commands. Correctly attribute elements of ideas to owners. |
| PC.5.1 | Identify and create commands that can be given to a computer to cause future interactions (e.g., timers, setting up events, define classes, etc.) |
| PC.A.15 | Engage in collaborative conversations about programming topics with increasing complexity. |
| PC.B.15 | Express personal preferences related to technology and programming. |
| PC.C.12 | Demonstrate an understanding that computers use a different type of language than humans. |
| PC.D.25 | Engage in academic discourse related to programming concepts using proper vocabulary: algorithm, sequence, logic statements, problems, solutions, commands, etc. |
| Social Emotional Learning | |
|---|---|
| SEL.K.1 | Identify personal and peers’ likes and dislikes, needs and wants, strengths and skills. |
| SEL.K.2 | Identify and explain differences in two approaches with successful solutions (e.g., “I solved it this way and (name) did it this way, but we both solved the problem.”). |
| SEL.K.3 | Discuss and demonstrate positive characteristics of successful programmers including resilience, attention to detail, and passion for learning. |
| SEL.K.4 | Cultivate a helping mentality: giving help and asking for help when appropriate. |
| SEL.K.5 | Describe an experience with failure and what you learned from it (e.g., “When it didn’t work, I realized I forgot a command. Next time I will remember to double check my solution.”). |
| SEL.1.1 | Describe similarities and differences in people, skills, approaches, and ideas that can have an impact on programming. |
| SEL.1.2 | Describe a problem solved by a peer with a different approach. Articulate what you learned from this (e.g., there isn’t only one answer, my way isn’t the only way, people do things differently, I don’t have to be right, I can learn from others, etc.) |
| SEL.1.3 | Name traits that you share with successful programmers (e.g., I work hard, I don’t give up, I help others, I am confident, I am focused, I want to learn, etc.). Give examples. |
| SEL.1.4 | Cultivate a helping mentality: giving help and asking for help when appropriate. Articulate how helping and needing/getting help feels. |
| SEL.1.5 | Describe a time you failed at something, name feelings associated with failure, and express what you learned from it. |
| SEL.2.1 | Engage in conversation about the impact different people, skills, ideas, and learning styles contribute to programming. |
| SEL.2.2 | Demonstrate flexibility around problem solving (e.g., there is more than one way, things can change, I can change my mind, etc.) |
| SEL.2.3 | Identify personal traits that make you a successful problem-solver and programmer (e.g., I don’t give up, I’m curious, I’m creative, I’m focused, I set goals, etc.) |
| SEL.2.4 | Demonstrate the importance of helping through teaching, working together, sharing, and asking questions. |
| SEL.2.5 | Describe personal skills and interests that one wants to develop, including skills and interests that have grown (e.g., I can subtract now, I know my doubles, I can read more words, etc.). |
| SEL.3.1 | Demonstrate an ability to collaborate through creation and revision (objects and solutions). |
| SEL.3.2 | Generate alternative solutions and evaluate the impact for a range of programming and real world scenarios. |
| SEL.3.3 | Set and monitor progress on achieving a short-term personal goal. *Also repeated when thinking about personal areas for growth |
| SEL.3.4 | Identify and perform roles that contribute to the school community. |
| SEL.3.5 | Set and monitor progress on achieving a short-term personal goal. |
| SEL.4.1 | Demonstrate an ability to solve conflict and come to a solution. |
| SEL.4.2 | Seek input from others in order to solve a problem or move the work forward. |
| SEL.4.3 | Set and monitor progress on achieving a short-term personal goal with increasing complexity and evidence of planning. *Also repeated when thinking about personal areas for growth |
| SEL.4.4 | Evaluate one’s participation in the class or school community to address an identified need. |
| SEL.4.5 | Set and monitor progress on achieving a short-term personal goal with increasing complexity and evidence of planning. |
| SEL.5.1 | Provide and incorporate feedback on products and ideas within programming scenarios. |
| SEL.5.2 | Incorporate multiple perspectives and needs to create a solution. Explain how the solution adequately addresses those perspectives and needs. |
| SEL.5.3 | Analyze why one did or did not achieve a goal, using knowledge about ones skills and strengths. *Also repeated when thinking about personal areas for growth |
| SEL.5.4 | Identify how personality traits (honesty, respect, fairness) enable a group to make decisions and work together to solve a problem, or contribute to a helping mentality. |
| SEL.5.5 | Analyze why one did or did not achieve a goal, using knowledge about one’s skills and strengths. |