Ferrous Systems is a Berlin-based Rust consultancy that sells live, instructor-led training to companies and individually-registered professional engineers, with a deep specialization in embedded and safety-critical Rust. Rustify is a 9-week mentored program built around a different job: taking a developer with programming experience but no Rust job, and getting them hired.
If you already work as a professional engineer and want formal, expert-led training in Rust or embedded Rust, especially if your target is automotive, aerospace, or medical-grade Rust, Ferrous Systems is genuinely one of the strongest options that exists. If you are trying to break into your first Rust role and need a structured path, code review on your own project, and a career-support layer, Rustify is the better fit.
By Max Wells, updated September 2026
TL;DR: Ferrous Systems is a real Rust consultancy founded by core Rust contributors, offering scheduled live courses (Introduction to Rust, Embedded Rust) plus custom-quoted team training and the Ferrocene safety-certified toolchain. Rustify is a 9-week Rust-only program with human code review on your own project and career support aimed at landing a job.
- Ferrous Systems: live, expert-led courses for employed engineers and their employers, with unmatched embedded/safety-critical depth
- Rustify: structured 9-week path with code review and career support for someone trying to get hired
- Feedback loop: Ferrous Systems = live classroom teaching plus an optional paid chat-support add-on; Rustify = line-by-line human code review of your own project throughout
- Best combo: Rustify to build backend-web Rust ability and get hired, then Ferrous Systems later if your role moves into embedded or safety-critical Rust
Quick Comparison: Rustify vs Ferrous Systems
| Rustify | Ferrous Systems | |
|---|---|---|
| Format | Guided 9-week program, cohort-based | Live instructor-led courses, scheduled or custom-quoted, remote-only |
| Scope | Rust only, fundamentals to production async/web | Rust only, core language plus a deep embedded/bare-metal/safety-critical track |
| Teaches syntax from scratch | Yes | Yes for Introduction to Rust, but built for working professional engineers, not total beginners |
| Feedback | Line-by-line human code review of your own project | Live instructor teaching during fixed sessions, plus an optional paid "Rust-Experts" chat add-on with small-scale code review |
| Projects | 3-4 deployed projects (CLI, library, auth API) | Hands-on in-session exercises (e.g. a working USB device via RTIC); no capstone or portfolio project |
| Career support | Portfolio audit, interview prep, salary negotiation | None found |
| Time commitment | 10-15 hours/week for 9 weeks | 5 full days (Introduction) or 3 half-days (Embedded), scheduled cohorts |
| Pricing | Program fee (see rustify.rs) | Individual courses published: around 2,250 euros for Introduction to Rust, around 1,350 euros for Embedded Rust (as of September 2026); team training custom-quoted |
| Best for | An individual career switcher landing a Rust job | An employed engineer, or their employer, formalizing Rust or embedded/safety-critical Rust skills |
What Is Ferrous Systems and How Does It Work?
Ferrous Systems is a Berlin-based Rust consultancy, founded in 2018 by core Rust project contributors, that sells live instructor-led training to companies and individual professional engineers, alongside a certified toolchain for safety-critical Rust called Ferrocene.
The company is a registered GmbH with managing directors Florian Gilcher and Felix Gilcher, and a distributed team that LinkedIn lists at 11 to 50 employees. Florian Gilcher co-founded the Berlin Rust meetup and the RustFest conference and has trained Rust professionally since 2015; co-trainer Jonathan Pallant is a founding member of the Rust Embedded Working Group. Ferrous Systems is also a founding member of the Rust Foundation Trusted Training program, a Foundation-recognized quality mark for training providers.
Its business has three parts: live, remote, instructor-led training (both custom-quoted team packages and scheduled courses for individually-registered professionals, partly resold through sales partner KDAB); bespoke Rust development and "team augmentation" consulting; and Ferrocene, a qualified Rust toolchain for safety-critical systems certified against automotive (ISO 26262), industrial (IEC 61508), and medical (IEC 62304) standards, now a major product line with its own domain and release cadence.
The core "Introduction to Rust" course starts from rustup and cargo basics and moves through ownership, error handling, collections, traits, generics, and concurrency primitives, so it does teach from scratch. But the framing throughout is "your team" and "professional engineers," not career changers, and there is a separate, deep Embedded Rust track covering HALs, PACs, RTIC, and the Ferrocene toolchain on real hardware like the Nordic nRF52840-DK. Nothing in the public curriculum reaches async, Tokio, Axum, or sqlx: the scope stops at core-language mastery plus embedded/systems depth.
What Is Rustify and How Does It Work?
Rustify is a 9-week intensive program that covers only Rust, from the toolchain and ownership model through async, HTTP APIs with Axum, and database integration with SQLx. Every project is reviewed line by line by engineers with production Rust experience, and the final weeks are dedicated to landing a Rust role.
The structure is a week-by-week curriculum where each concept is applied immediately in a project rather than learned in isolation. Weeks 1 to 3 build the ownership and borrowing foundation, weeks 4 to 5 introduce traits, generics, and workspace structure, and weeks 6 to 8 deliver the async and HTTP stack that shows up in every backend Rust interview. Week 9 is career positioning: portfolio audit, interview preparation specific to Rust roles, and salary negotiation for the scarcity premium.
You leave with 3 to 4 deployed, publicly reviewable projects. The centerpiece is an authenticated REST API built with Axum and PostgreSQL via SQLx, with middleware, input validation, integration tests against a real test database, and a live URL. That is the artifact hiring managers actually open.
The trade-off is intensity. Rustify assumes at least a year of prior programming experience in any language and expects 10 to 15 hours per week for nine consecutive weeks. It is not a casual, learn-on-weekends option, and it is not aimed at embedded or safety-critical Rust, where Ferrous Systems is the stronger, more specialized choice.
Rustify vs Ferrous Systems: The Core Difference
Ferrous Systems teaches Rust (and embedded Rust specifically) at expert depth through live classroom sessions aimed at already-employed engineers and their employers. Rustify builds an individual career changer, end to end, toward a first Rust job.
Three structural differences drive everything else:
- Fixed classroom sessions vs a sequenced curriculum with a portfolio outcome. Ferrous Systems runs scheduled, instructor-led courses (a week for Introduction, a few days for Embedded); Rustify sequences nine weeks so each week's project depends on the last, ending in a deployed, reviewable API.
- Live teaching plus optional paid chat support vs ongoing human code review. Ferrous Systems' feedback model is live instruction during the session, plus an optional "Rust-Experts" chat add-on (available only after a first training purchase) that offers small-scale code review. Rustify's code review is built into every week, on the learner's own project, throughout the program.
- Employer-funded upskilling vs individual career support. Ferrous Systems has no job board, resume review, mock interviews, or placement layer, because it is not built for that; Rustify's week 9 exists specifically to turn finished projects into interviews and offers.
Neither model is wrong. They target genuinely different people: Ferrous Systems for an engineer (or team) already employed and formalizing Rust or embedded-Rust skill, Rustify for someone trying to get hired into a first Rust role.
Is Ferrous Systems Worth It for Learning Rust?
Ferrous Systems is worth it if you are an already-employed professional engineer, or your employer is funding the seat, and you want live, expert-led Rust training, especially if embedded or safety-critical Rust is the target. It is not built for someone with no employer sponsorship trying to break into a first Rust job.
Where Ferrous Systems delivers strong value:
- Depth and pedigree that is genuinely hard to match. The trainers are actual Rust core contributors and Rust Foundation founding members, which gives it arguably the strongest teaching authority on Rust internals, the compiler, and embedded Rust of any training provider in this space.
- Embedded and safety-critical specialization. No self-paced course or bootcamp in this space teaches
no_std, RTIC, HALs, and PACs the way Ferrous Systems does, and its Embedded Rust curriculum maps directly to the Ferrocene toolchain, which is independently certified against ISO 26262, IEC 61508, and IEC 62304. For an engineer targeting automotive, aerospace, or medical Rust roles, this is a real, unique advantage. - Enterprise trust signal. Named clients and testimonials (Tweede golf, Linaro, SUSE) plus Rust Foundation Trusted Training membership give it institutional credibility that a solo-run course cannot match. Independent press has also confirmed Ferrocene's safety certifications, which is a stronger signal for a B2B consultancy than review-site scores.
- Content stays current. The company's blog and teaching-material repos are actively maintained, with recent posts and commits close to any given check date.
Where it falls short for someone trying to get hired:
- No web/backend curriculum. Nothing in the public course list mentions async, Tokio, Axum, Actix-web, sqlx, or Diesel, so it does not build the backend-web skill set most Rust job postings ask for.
- No career layer. There is no job board, resume review, mock interviews, or placement support anywhere on the site; the closest thing to career content is a manager briefing about whether to adopt Rust at all, not how to get hired.
- Feedback is classroom teaching, not review of your own project. The main feedback mechanism is live instruction during a fixed session. Ongoing, small-scale code review exists only as a paid add-on you can buy after a first purchase, and it is not scoped as structured review of a learner's own end-to-end project.
- No portfolio output. Learners keep training materials and completed in-session exercises, but there is no capstone project, certificate, or published-crate requirement described for either track.
Thinking about making the switch to Rust?
See if your background fits — a 2-minute check.
Who Should Choose Ferrous Systems?
Choose Ferrous Systems if you are an already-employed professional engineer, or you are deciding for your team, and you want live, expert-led Rust training from core Rust contributors, especially for embedded or safety-critical work.
Good fit if you:
- Are a working engineer whose employer will fund formal Rust training
- Are targeting embedded, safety-critical, automotive, or aerospace Rust work where Ferrocene is directly relevant
- Want to learn from actual core Rust contributors and Rust Foundation founding members
- Are deciding, as a manager, whether your team should adopt Rust at all
- Value a scheduled, live classroom format over self-paced or async learning
Poor fit if you:
- Have no employer sponsoring the seat and are trying to break into a first Rust job
- Need a backend/web curriculum: Axum, sqlx, and async are not covered
- Want ongoing, structured review of your own project rather than fixed classroom sessions
- Need career support: resume help, interview prep, or a job-search plan
Who Should Choose Rustify?
Choose Rustify if you are an experienced developer switching into Rust and you want the fastest structured path to a role at USA or European market rates, with a mentor reviewing your code and a plan for the job search.
Good fit if you:
- Have 1+ years of professional experience in any language
- Are targeting a specific outcome: a Rust job, a salary increase, or a company you cannot reach today
- Can commit 10 to 15 hours per week for nine weeks
- Want your own project reviewed line by line, not a fixed classroom session
- Want career support that is specific to the Rust hiring market
Poor fit if you:
- Are a complete beginner to programming
- Need embedded or safety-critical Rust depth: that is Ferrous Systems' specialty, not Rustify's
- Only want casual exploration with no career goal
Can You Use Rustify and Ferrous Systems Together?
Yes, and the sequencing depends on what you need first. For most individual career changers, Rustify comes first to build backend Rust ability and get hired; Ferrous Systems becomes relevant later if the job moves toward embedded or safety-critical Rust, or if an employer is funding formal training.
A practical order:
- Rustify (weeks 1 to 9): learn Rust properly, build the auth API, get code review, run the job search, land a role.
- Ferrous Systems (once employed, if relevant): if the new role touches embedded, automotive, or safety-critical systems, an employer-funded Ferrous Systems course or the Ferrocene toolchain becomes directly useful in a way it would not be pre-hire.
- Team training: if you move into a lead or manager role, Ferrous Systems' team-oriented courses (or the "Why Rust?" briefing) are a reasonable way to bring a wider team up to speed.
Doing this in the other order rarely makes sense for a career changer: Ferrous Systems has no career-support layer, so a course alone does not turn into a job offer.
How Do the Costs Compare?
Ferrous Systems publishes per-person prices for individual courses; Rustify is a one-time program fee that includes structured curriculum, ongoing human code review, and career support rather than a scheduled classroom session.
What each one is buying, as of September 2026 (check ferrous-systems.com/training for current numbers before deciding):
- Ferrous Systems buys a week of live, expert-led Introduction to Rust training for around 2,250 euros per person, or a 3-day Embedded Rust course for around 1,350 euros per person. Team training is custom-quoted. This buys expert instruction and Rust Foundation-recognized quality, not a job-search plan or a portfolio project.
- Rustify buys nine weeks of a sequenced curriculum, line-by-line code review of your own deployed projects, and a dedicated career-support phase. The return is measured against the salary delta: a developer moving from a $120,000 role to a $155,000 Rust role recovers the program cost inside the first few months of the new salary, before any long-term progression.
If your employer is funding formal training and your target is embedded or safety-critical Rust, Ferrous Systems is the stronger, more specialized spend. If the constraint is time-to-hired with no employer backing you, the mentored path is usually the better return once you price in the months of stalled self-study it replaces.
Frequently Asked Questions
Yes, for the right audience. Ferrous Systems is a real Rust consultancy founded by core Rust contributors, and its Embedded Rust and Ferrocene-aligned training is arguably unmatched in this space for safety-critical and automotive/aerospace Rust work. It is worth it if you are an already-employed engineer, or your employer is paying, and formal live instruction is what you need. It is not built to get an unemployed career changer hired.
Yes, for its Introduction to Rust course, which starts at rustup and cargo basics. But the audience is framed as working professional engineers and teams, not total beginners to programming, and there is no career-change or job-search layer once the course ends.
Not for career-change beginners. The curriculum teaches core Rust from the basics, but the entire site is framed around companies onboarding existing engineering teams and individual working professionals, not people trying to break into their first Rust job with no employer sponsoring the seat.
Rustify. It covers backend-web Rust (Axum, sqlx, async) that Ferrous Systems' public curriculum does not reach, reviews your own project line by line throughout the program, and includes a dedicated career-support phase, none of which Ferrous Systems offers for individuals.
Rustify, if the goal is a first Rust job without employer sponsorship. It is built around a job outcome: a reviewed, deployed portfolio and career support ending in interview and salary negotiation prep. Ferrous Systems has no career-support layer at all; it is built for employed engineers and teams formalizing Rust skill, not for turning skill into an offer.
As of September 2026, individual scheduled courses are published at around 2,250 euros per person for the 5-day Introduction to Rust course and around 1,350 euros per person for the 3-day Embedded Rust course. Team training is custom-quoted and not published. Always confirm current numbers on ferrous-systems.com/training before deciding, since prices can change per cohort.
Sources
- Ferrous Systems: Company overview, team, and business lines
- Ferrous Systems Training: Full curriculum, published individual prices, and trainer bios
- Ferrous Systems on GitHub: Teaching-material repos and open-source contributions
- Rustify Bootcamp: Full curriculum and enrollment details
- Stack Overflow Developer Survey 2024: Rust developer salary and demand data
- Levels.fyi: Compensation benchmarks for Rust roles
Keep Reading
- Rustify Bootcamp Review 2026: Curriculum, Projects, and Who It's For: The full breakdown of the program compared here
- Is a Rust Bootcamp Worth It? Honest ROI Analysis: The cost-vs-salary math behind a structured program
- Best Rust Courses and Bootcamps 2026: How the structured options compare
- 9-Week Fullstack Rust Bootcamp: See the full curriculum and enrollment details
- Rustify vs CodeCrafters in 2026: How Rustify compares to a self-directed challenge platform
Related Glossary Terms
- Ownership: The model both Rustify and Ferrous Systems teach from the ground up
- Borrow Checker: The wall most self-study attempts hit without review or live instruction
- Async/Await: Core to Rustify's backend curriculum, absent from Ferrous Systems' public course list
- Tokio: The async runtime behind Rustify's HTTP projects
- Axum: The framework for Rustify's reviewed portfolio API
- SQLx: Compile-time checked SQL used in Rustify's centerpiece project
