Academy · Curriculum
One curriculum,
many specialties.
A structured 12-week program that turns motivated people into job-ready specialists — across Guidewire, AI & ML, Data, and Cloud & Cyber. Same rigor, same phases, built backward from what employers actually hire for.
Tracks
Choose your specialty
Guidewire is one track among several. Every track runs the same structured program — we just point it at a different in-demand field where hiring runs short.
Guidewire
PolicyCenter, ClaimCenter, BillingCenter — product model, Gosu development, integration, and cloud delivery for P&C carriers.
$115–165/hrAI & ML Engineering
Applied machine learning, LLM and RAG systems, model serving, and the integration work that gets AI into production — not just notebooks.
$195–260/hrData & MLOps
Data pipelines, warehousing, feature stores, and the MLOps practices that turn a trained model into a reliable production service.
$110–165/hrCloud & Cyber
Cloud architecture, infrastructure as code, and security fundamentals — identity, detection, and hardening woven through every build.
$135–220/hrEach track is built around roughly 100 core concepts a specialist must know to be effective on day one — taught, demonstrated, and practiced in hands-on labs.
The program
Foundations to job-ready
Twelve weeks with the same shape no matter the specialty — four stages, foundations through job-readiness, where competency builds progressively into a capstone that mirrors real delivery.
Orientation & fundamentals
Foundations · Weeks 1–2Ground the cohort in how the field actually works before any track-specific code. Learners set up their environment, learn the platform's mental model, and lock in the shared engineering basics every track is built on.
What it covers
- Domain context, vocabulary, and how value is delivered
- Local environment, tooling, and source control setup
- Core language and the platform's architecture overview
- Engineering fundamentals: clean code, data, and Git workflows
Core competencies
Core · Weeks 3–6The deep, track-specific skills employers screen for on day one. Each concept is taught, demonstrated live, then practiced in a graded lab — so understanding is proven, not assumed.
What it covers
- Data models, configuration, and core development patterns
- Track-specific modules taught concept by concept
- A hands-on lab for every concept, reviewed by an instructor
- First milestone checkpoint against the readiness rubric
Build & integration
Core · Weeks 7–9Advanced patterns and the connective tissue of real systems — APIs, messaging, and third-party integration. Learners stop doing isolated exercises and start building features that mirror production scenarios.
What it covers
- Advanced patterns, custom logic, and edge-case handling
- API design, integration, and event-driven flows
- Connecting to external systems the way teams really do
- Code review on real pull requests, not toy snippets
Capstone build
Project · Weeks 10–11An end-to-end capstone that simulates a real client engagement — requirements through a working, deployed system. This is the portfolio piece a hiring manager can actually look at and probe.
What it covers
- Requirements, scoping, and a delivery plan in sprints
- Build, integrate, and deploy a production-shaped system
- Environment management, observability, and security basics
- Documentation and a knowledge-transfer handover
Certification & interview prep
Job-readiness · Week 12Turn a finished build into a finished candidate. Capstone defense, certification preparation where one exists for the track, and the mock-interview reps that get learners ready for the conversation, not just the exam.
What it covers
- Capstone defense and a final readiness assessment
- Certification prep aligned to the track's industry exam
- Résumé, portfolio, and technical-story coaching
- Mock technical and behavioral interviews with feedback
The weekly rhythm
What a week actually looks like
The program is intensive on purpose — that's what builds a job-ready specialist. Here's the rhythm a cohort runs on, the same loop real delivery teams use.
Live instruction
Practitioners teach the day's concepts live — not pre-recorded video. Sessions are interactive, and every one is recorded so learners can revisit the parts that matter.
Hands-on labs
Each concept comes with a lab that has to be built, not just watched. Labs are graded against a rubric, so learners always know exactly where they stand.
Code review
Learners open pull requests and get them reviewed the way a real team would — concrete, line-level feedback that moves skill forward faster than any lecture.
Office hours
Dedicated time to get unstuck, ask the question you didn't want to ask in class, and go deeper on a topic with someone who does the work for a living.
Demo & retro
At each milestone, learners demo what they built and reflect on what to sharpen next — the same show-and-tell rhythm real delivery teams run on.
Learn, build, ship — every week
Every week closes the loop: a concept taught, a lab built, code reviewed, and progress demoed. Skill compounds because nothing is left half-understood.
What you build
Finish with proof, not just notes
The curriculum is built around shipping. Learners leave with a portfolio they can show a hiring manager — concrete work and the ability to talk through it, not a stack of certificates alone.
A production-shaped capstone
Not toy exercises. Each learner ships a capstone that mirrors a real client engagement — from requirements to a working, deployed system they can demo end to end.
Real integrations
APIs, messaging, and external-system connectivity built the way teams actually do it — the work that separates job-ready from coursework-only.
A deployed, running system
Learners deploy what they build to the cloud, manage environments, and operate it — so they have run something, not just written it.
A reviewed code history
A Git history of real pull requests and review feedback — proof of how they work, not just what they finished.
Documentation & a handover
Clear docs and a knowledge-transfer write-up, because shipping isn't done until the next person can run it.
An interview-ready story
A portfolio and a rehearsed technical narrative — the artifact and the ability to talk through it under questioning.
Shared foundations
Skills every track is built on
Engineering fundamentals
Clean code, data structures, and design patterns that underpin every track — from Guidewire configuration to AI services.
Data & SQL
Relational and analytical data concepts, query writing, and schema design used in every implementation we train for.
Version control & CI/CD
Git workflows, branching, and continuous delivery — the team practices enterprise employers expect from day one.
Agile delivery
Sprint planning, story writing, and the delivery rhythm of real engagements, so graduates fit a team immediately.
Assessment
Skill that's proven, not assumed
Nobody coasts to a certificate. Progress is measured the whole way through — so by the end, job-ready isn't a claim, it's something a learner has demonstrated.
Graded labs
Every concept is checked with a lab scored against a rubric. There's no hand-waving past a skill — if a lab isn't passing, the learner knows precisely what to fix.
Milestone checkpoints
At the end of each phase, an instructor reviews progress against the readiness bar. Checkpoints catch gaps early, while there's still time to close them.
Capstone defense
The capstone is demoed and defended under real questions — design choices, trade-offs, and what they'd do differently. Building it is only half the bar; explaining it is the rest.
Certification & readiness
Where the track has an industry certification, we prep for it directly. Every learner ends with a final readiness assessment mapped to what employers actually hire for.
Mentorship
Taught by people who do the work
Curriculum is only half of it. The other half is the people in the room — practitioners who review your code and point you at the next thing to learn.
Practitioner instructors
Taught by people who do the work — our own founder still writes production code. Learners get patterns from the field, not from a textbook.
Small cohorts, real feedback
Cohorts stay small so every learner gets reviewed code, direct answers, and the kind of feedback that actually moves skill forward.
A path to placement
The curriculum is built backward from what employers hire for — so finishing it means being ready for the interview, not just the exam.
Who it's for
No experience required, just commitment
We teach from the ground up. What matters isn't where you start — it's that you show up and build every day. These are the people who thrive in a cohort.
Motivated career-changers
No prior experience in the track is required. We teach from the ground up — what we need is the commitment to show up and build every day.
Early-career engineers
People with some technical footing who want to go deep in a high-demand specialty and come out genuinely hireable in it.
Specialists pivoting fields
Practitioners moving from an adjacent area — say, on-prem to cloud, or analytics to ML — who need a structured path into the next thing.
What you'll need
The practical prerequisites
- A laptop capable of running the dev environment
- Reliable internet for daily live sessions
- Comfort with basic computing — we cover the rest
- Roughly full-time focus across the program
Questions
The curriculum, answered
The things people ask before they apply — answered straight.
Do I need experience to start?
No track experience is required — we teach from the ground up. Phase one covers the engineering fundamentals every track is built on, so motivated beginners and career-changers can keep pace. What you do need is the commitment to show up and build daily.
How long is the program and what's the time commitment?
Each track runs roughly twelve weeks, full-time. Expect daily live instruction, a hands-on lab for every concept, weekly code review, and office hours — the rhythm is intentionally intensive because that's what produces a job-ready specialist.
Is it the same curriculum for every track?
Every track shares the same shape — foundations, core competencies, a capstone build, then job-readiness — and the same shared engineering foundations. The core modules are track-specific: Guidewire learners build on PolicyCenter and Gosu, AI learners on RAG and model serving, and so on.
Will I earn a certification?
Where the track maps to an industry certification, the final phase preps you for it directly. Beyond any exam, you finish with a defended capstone, a portfolio, and a readiness assessment — the proof of skill hiring managers actually weigh.
What do I actually build?
An end-to-end capstone that mirrors a real client engagement: requirements through a working, deployed system, with real integrations and a documented handover. You also leave with a reviewed code history and a rehearsed technical story to talk through in interviews.
Who teaches the program?
Practitioners who do this work for a living — our founder still writes production code. Cohorts stay small so every learner gets reviewed pull requests, direct answers in office hours, and feedback that moves skill forward, not a recorded video and a forum.
What happens after I finish?
The curriculum is built backward from what employers hire for, and graduates move toward real roles through the same network we staff every day. We lay out the honest outcomes plainly — placement paths and where graduates land, no inflated numbers.
Weeks per program
Specialist tracks
Core concepts mastered
Original curriculum
Get started
Pick a track and get built into a specialist.
No prior experience required — we teach from the ground up. Tell us which field fits you and we'll show you the path to job-ready.