The Techtonica curriculum, a self-directed JavaScript program for low-income trainees

A repository of lessons, not an application

The name suggests a software project and the contents say otherwise. This repository is the curriculum of Techtonica, a non-profit project of SocialGood that offers software engineering training with need-based, sliding-scale, subsidized tuition and stipend scholarships, aimed at women and non-binary adults with low incomes who are unemployed or underemployed. What you find inside is Markdown.

The top-level entry list reads like a subject index rather than a codebase: agile-development/, algorithms/, api/, career/, css/, data-structures/, data-visualization/, databases/, debugging/, deploying/, dev-tools/, electives/, express-js/, functional-programming/, git/, javascript/, node-js/, onboarding/, pair-programming/, projects/, react-js/, recursion/, refactoring/, runtime-complexity/, security/, testing-and-tdd/ and more, alongside project directories with spaces in their names such as application workshops/. The primary language is JavaScript because that is what the program teaches, not because there is a running system to inspect.

The one piece of real tooling is a small Node package manifest, and it exists to keep the prose tidy. That is the entire technical surface area, and being clear about it is the first thing to understand before spending time here. If you are evaluating this as an engineering dependency, there is nothing to depend on. If you are evaluating it as a curriculum, the interesting part is the sequence of topics and the way the program is structured around self-directed work.

Fifteen weeks sequenced from pre-work to a final project

The table of contents in the project documentation lays out the whole program. It runs from Week 0 through Week 15 and beyond, and the project is explicit that this is an approximate sequence that is always being tuned and optimized, with questions handled through an issue.

The shape of it is worth reading carefully. Week 0 is pre-work, where participants meet weekly for four weeks to learn JavaScript fundamentals and are expected to memorize common JavaScript built-in functions within the first month. Week 1 handles onboarding and developer tools. Week 2 covers webpages with HTML and CSS, Week 3 JavaScript fundamentals, Week 4 intermediate JavaScript and React, Week 5 web APIs, Week 6 databases, Week 7 advanced JavaScript and React, Week 8 testing. Week 9 is a project called Eventonica, Week 10 more of the PERN stack plus review, Week 11 two full stack projects in one week, Week 12 final assessments, Week 13 is career week, Week 14 is project prep plus electives, and Weeks 15 and later are the final project.

Two structural choices stand out. The stack is JavaScript throughout, with React and the PERN components (PostgreSQL, Express, React, Node) appearing explicitly, and the technical content is interleaved with career topics from week one onward: roles in tech, networking, professional branding, how to learn, and how to write documentation. There is also a standing set of appendices for soft skills, independent topics, optional lessons, data structures and algorithms.

The compression in Week 11 is deliberate and tells you the pedagogy. Two full stack projects in a single week is the pace of a working developer, not a classroom.

The pedagogical bet is that nobody guides you

The most distinctive thing in the project is not a topic list, it is a decision about instruction. The documentation states that Techtonica aims to be more like the workplace to make the transition into the industry better, and that instead of having an instructor constantly guiding you, which you will not have in any software engineering job, participants are given a general schedule of topics and assignments and are expected to figure out what to do on their own or in collaboration with volunteers, mentors, tech groups and other participants.

The comparison the documentation draws is with bootcamps, which it describes as intensive training that is often passive classroom learning and costs $15,000 or more for the students. Techtonica is also intensive, and the differentiation claim rests on two axes: cost and structure.

The consequence for anyone studying the repository is that each lesson has to be self-explanatory. There are no instructor notes, no live exercises with a teacher present, and no slides. What there are, per the file listing, are prompts and worksheets: a Recipe Page project split into a Phase 1 HTML prompt, a Phase 2 CSS prompt, Phase 3 Bootstrap and Phase 4 DOM Manipulation, a portfolio project with a webpage build, a personal branding component and a collaboration and review document, and a Week 1 review worksheet. The unit of content is the assignment, and the assignment is written to be worked through alone.

Week 1 shows the register the project expects. Alongside command line interface tools, advanced command line, a Bash profile and Vim, the list includes asking good questions, living in open workspaces or working remotely, keyboard shortcuts, ergonomics and a growth mindset lesson plan. The expectation is that a trainee learns how to be a working developer, not only how to write code.

Prettier, remark and a husky hook keep the Markdown consistent

A curriculum repository is mostly prose and links, and prose that is edited by forty volunteers rots quickly. The package manifest addresses that with a small chain of Markdown tooling, and it is the one part of this project you can actually run.

The scripts section of the manifest declares four commands.

  "scripts": {
    "precommit": "lint-staged",
    "postcommit": "git update-index --again",
    "validate-links": "remark .",
    "prettier": "prettier --write ."
  },

Prettier rewrites the Markdown and JSON formatting across the repository, and remark validates it. The link checking is the interesting part, because a curriculum is mostly a graph of internal links between lesson files, and a broken relative path is a dead end for a student working alone. The remark configuration for the no-dead-urls plugin skips localhost and skips the codepen.io and github.com URL patterns, so external link rot on those two hosts is deliberately tolerated rather than failing the check.

The commit hooks make the formatting and the staged-file checks automatic rather than advisory.

  "husky": {
    "hooks": {
      "pre-commit": "npm run prettier && lint-staged",
      "post-commit": "git update-index --again"
    }
  },

The dependency set is small and legible: husky, lint-staged, prettier, remark-cli with remark-lint, remark-validate-links and remark-lint-no-dead-urls on the development side, and a handful of Git-related runtime packages in the dependencies block. The lint-staged configuration is scoped to Markdown files. Contributors are pointed at a CONTRIBUTING.md for the workflow, and there is a CODE_OF_CONDUCT.md alongside it, which tells you something about the scale of the contributor base this structure was designed for.

What this repository cannot do for you

Being clear about the boundary prevents a wasted afternoon. This is a document set, not a system. It has no automated assessments, no grading, no student tracking, no progress reporting and no tests that verify a trainee learned anything. It cannot be enrolled in, tracked, or administered by a learning management system without work you build yourself.

It also cannot be consumed as a self-study path without adaptation, because the program assumes a support structure that a curriculum repository cannot provide. Participants are expected to work with volunteers, mentors, tech groups and each other. Take the same documents into a room with no community and no office hours, and the self-directed approach that makes Techtonica distinct becomes the reason people stall. The documentation is candid about this by comparison, framing the absence of an instructor as a feature that mimics the workplace, which is a defensible design choice for a job placement program and a poor fit for a self-study library.

Two smaller gaps are visible in the file listing itself. The security/ and docker/ directories exist, so topics like those are covered somewhere, but the visible sequence for weeks 0 through 3 does not show where they land, and the sequence is stated to be approximate. And the career topics are extensive enough to be a program in itself, which means a curriculum designer reusing this needs to decide whether the employment half is part of their course or belongs to a mentoring track.

The programming language coverage is also worth noting honestly: the topics are JavaScript, with React on the front end and a PERN stack on the back. A program that teaches Python, Go or Rust has no equivalent lessons here to start from.

How it differs from a paid bootcamp and from a link dump

The alternative is not another open source curriculum, it is the paid bootcamp the documentation compares itself to, and the difference in approach is structural rather than cosmetic.

A paid bootcamp sells a schedule, an instructor and a cohort. The instructor drives, the classroom is passive by the documentation's own description, and the price tag starts above $15,000 per student. Techtonica sells a curriculum, a stipend and job placement or job search support, with tuition that is need-based, sliding-scale and subsidized, and the instruction is delegated to volunteers and mentors rather than held by a single instructor in the room. The trade is not free training against paid training, because volunteer labor is what makes the tuition low, and the documentation is explicit that participants are expected to figure things out on their own or with the help of volunteers, mentors, tech groups and other participants.

The other alternative is a link dump: a folder of tutorials and blog posts with no sequence. The difference here is that the sequence is the artifact. A trainee is told what to do in what order, and the projects are staged, with the Recipe Page moving from HTML to CSS to Bootstrap to DOM manipulation and the portfolio project moving from a single webpage through branding to a collaboration and review exercise. A link dump cannot tell a beginner why the DOM comes after CSS, and it cannot tell a mentor which week a student is on.

The practical comparison for an adopter is between a curriculum you maintain and a curriculum you inherit. This one is revised by a program with an incentive to keep it current, which is worth something, and it comes with a link-checking pipeline that a hand-assembled course would need from scratch.

Licence details and the state of the repository

Two licensing facts sit in this repository and they do not agree. The project is published under CC-BY-SA-4.0, which is the licence used for the curriculum content and is appropriate for a share-alike educational text. The licence field inside package.json declares ISC instead. Both are permissive, and neither is a copyleft obligation that would reach a trainee's own project code, but the mismatch is the kind of thing to check before you copy lesson text into a course you sell.

The repository has no GitHub releases. There is nothing to install and no versioned distribution, and the last push was on 2026-10-20, so the lessons on the default branch change as the program runs. The version field in package.json reads 1.0.0 and does not track the curriculum itself. Practically, that means there is no upgrade path in the usual sense: you clone, you read, and if you want to keep a copy of a particular state of the curriculum you keep your own fork and pin it.

Because the documentation states the sequence is continuously tuned, the practical risk for a reused curriculum is version drift. A cohort that starts in August and a cohort that starts in January may see different weeks, different project phases and different topic folders, since the order is being optimized as the program runs. Anyone building on top of this should treat the README as a live document rather than a stable specification, and pin to a commit if a stable sequence matters.

Editorial conclusion

This repository is worth adopting if you teach full-stack JavaScript to people starting from scratch, if you are looking for a sequenced set of assignments rather than a pile of links, or if you want to see how a program deliberately removes a teacher from the room. It is not a library, a framework or a tool, so there is nothing to install and no API to integrate, and it is a poor fit for a team that needs a maintained codebase or a curriculum with automated assessment and grading. Verify first that the week-by-week sequence in the README is current, since the project states the order is approximate and continuously tuned, and check the licensing inconsistency between the repository licence and the licence field in package.json before you redistribute any of the lessons.

Frequently asked questions

Official sources

1. Issues
2. License: CC-BY-SA-4.0
3. README
4. Techtonica/curriculum on GitHub