The Bradfield Computer Science Intensive

Note: Applications are now closed for the June 2023 cohort. The next cohort will commence June 2024, with applications opening in January 2024. To be notified when applications open, please sign up for our newsletter.

Bradfield CSI is an intensive, 12 month, live online program covering the core computer science concepts and engineering practices expected from senior software engineers at the industry's top companies. It is intended for early-to-mid career engineers wishing to expedite their path to higher impact, more fulfilling, and better remunerated roles.

It has never been easier to become a software engineer, even without a traditional computer science education. However, there is a widening gap between those who simply develop applications, and those who can understand, design, build, and maintain large-scale systems. Bradfield CSI is designed to help students methodically bridge this gap, without the expense or time commitment of a traditional master's program.

Program structure

  • Duration: 12 months
  • Time commitment: 10-15 hours/week
  • Cohort size: 20-25 students
  • Price: $19,500

The program consists of a 6-8 week preparation phase and 32 weeks of live instruction. During the live instruction phase, students complete 8 modules, each 4 weeks long, with short breaks between most modules and a longer break for winter holidays. Throughout the program, students also participate in monthly seminars (seminar topics include career development, personal productivity, and Q&A with industry guests).

Each module consists of 2 live classes per week (5pm-6:30pm PT, Monday and Thursday evenings, conducted via Zoom, with recordings uploaded as unlisted YouTube videos) as well as associated pre- and post-class work involving programming exercises, videos, and reading assignments. The expected time commitment is approximately 10-15 hours per week total (including the live classes).

Existing Bradfield students who wish to join the program are offered a tuition rebate of 1.2x any tuition paid to date for Bradfield courses (e.g. if you have taken two Bradfield courses with tuition totalling $3,600, your tuition for Bradfield CSI would be $19,500 - 1.2 * $3,600 = $15,180).

Self-paced preparation phase

The preparation phase is designed to ensure that every student enters with baseline understanding and skills that we'll assume thereafter. Prior to the start of live instruction, students are provided with self-paced material covering:

  • The Go and C programming languages
  • Practice using common command-line tools
  • Algorithmic analysis, fundamental algorithms and data structures

During the preparation phase, we will have weekly check-ins on Zoom to discuss the material; instructors will also be available on Slack to answer any questions.

The primary language for the program is Go. We chose Go for a variety of reasons, including relative simplicity (compared to alternatives such as C++ or Rust), sufficient ability to manage lower-level details (compared to alternatives such as Python), and increasing popularity for systems programming (compared to alternatives such as Java).

C is also used occasionally, to highlight low-level systems concepts as necessary, or to discuss important open-source projects implemented in C.

Although students do not need to know Go or C when applying for the program, students are expected to develop familarity with both languages by the end of the self-paced preparation phase.


Module Description Example exercises
1. Introduction to Computer Systems Machine representations of data and programs, the CPU execution model, exceptional control flow, low level programming, reverse engineering x86-64 and optimization, all from a programmer’s perspective. Implement a simple register-based virtual machine, reverse engineer x86 assembly, refactor a Go program to improve CPU cache utilization, write a shell with job control.
2. Systems Programming and Compilers Tools and abstractions from the systems programming environment: concurrency and parallelism, memory management and garbage collection, introduction to compilers and interpreters. Fix concurrency bugs, profile garbage collector performance, implement a tree-walk interpreter and a bytecode generator for a Go function's AST.
3. Computer Networks Understanding network protocols (particularly at the application, transport and network layers) with a focus on programming networked applications, understanding network infrastructure, and working with third party systems (such as cloud providers and third party CDNs etc). Parse a packet capture file, write a DNS client, write an HTTP proxy, and configure a VPC on AWS.
4. Data Structures for Storage and Retrieval In-depth investigation of how data structures are used in production systems, and how practical implementations differ from "textbook" versions. Case studies may include Go's standard library, LevelDB / RocksDB, Postgres, and Redis. Implement a clone of LevelDB for efficient key-value storage, with components such as skip lists, sstables, bloom filters, and log-structured merge trees.
5. Operating System Principles and Interfaces Learning how best to utilize the systems that sit between our applications and our computer systems, covering topics such as memory virtualization, task scheduling, file systems, and OS-level concurrency primitives. Create a simple file system with FUSE, create a simple container framework using cgroups, implement green threads on top of POSIX threads, measure a program's cache misses and page faults.
6. Relational Databases A behind-the-scenes look at relational databases in general, and PostgreSQL in particular. Physical storage, query execution, joins, planning and optimization, transactions and isolation levels, atomicity and durability. Implement core components such as query executors and join algorithms; interpret raw database files to extract meaningful data; optimize slow queries using planner output.
7. Distributed Systems Understanding principles and practical considerations for building high-scale data-intensive applications, and learning to reason about tradeoffs between fault tolerance, latency, throughput, consistency and operational overhead. Design and implement a simple distributed key-value store.
8. System Design and Operation System design practice combining the conceptual material and technologies covered in other classes, with case studies from real systems, and operational considerations such as deployment, observability and maintenance. Each exercise will be a new system design problem.

Additional Support

Throughout the program, students receive additional support in the form of:

  • Code reviews
  • Discussion and feedback over Slack
  • Office hours
  • Monthly seminars, with occasional industry guests

Teamwork / Collaboration

All projects are designed to be done individually (though this may change in the future). However, we still encourage students to collaborate with each other by discussing the projects, sharing ideas, reviewing each other's code, etc.


The admissions process involves:

  • A take-home exercise consisting of systems programming problems and questions about a computer science paper
  • An interview discussing the applicant’s solutions to the take-home exercise, as well as their goals and background

CSI is a challenging program. The goal of our admissions process is to ensure that incoming students are sufficiently prepared and likely to succeed in the program. In particular, we’re looking for students who are open-minded and motivated learners, productive programmers, and effective communicators.

Unfortunately, due to limited capacity and high volume of applications, we're not able to accept every applicant we believe is likely to succeed in the program.

A computer science degree is not required. However, industry experience is strongly recommend (for example, at least 1-2 years in a backend or full-stack software engineering role).


The instructors for the program are Oz Nova and Elliott Jin.

Oz co-founded Bradfield in 2015, and has since taught a wide range of foundational computer science topics to hundreds of self-taught engineers and bootcamp graduates, one small class at a time. Previously he was CTO and co-founder of Vida Health and Topguest.

Elliott has been an instructor and course developer at Bradfield since 2018. Previously he was a senior engineer at Dropbox, where he worked on distributed systems for storage and retrieval. In addition, he has experience as a mentor for the Google Summer of Code and a section leader for Stanford's introductory computer science course.

Note: Applications are now closed for the June 2023 cohort. The next cohort will commence June 2024, with applications opening in January 2024. To be notified when applications open, please sign up for our newsletter.