bRRAInDev · Practitioner
v2.0

bRRAIn Certified SDK Developer

Build, test and ship governed bRRAIn extensions in Go with Platform SDK v1.2.0.

Level
Practitioner
Learning time
18 hours
Price
$499
Credential
Valid 3 years
What's new in v2.0

What changed in this edition.

  • Rebuilt on the real Platform SDK v1.2.0 (package platformsdk). Every code sample compiles; v1 taught a fictional API and module path that never existed.
  • New coverage of the SDK's actual surface: vault files including images and PDFs, ingestion commit, LLM Registry and the Handler, MCP tools, integrations, OAuth, Operator ENV, policy, role lookup, audit and notifications.
  • Honest notes on current brain pod behavior, such as degraded substring search, role lookup returning 501, and the hard-delete zero value, so your code works on the pods your customers run.
  • Testing with httptest fakes that speak the pod's wire format, plus a full module on errors, deadlines and safe retries.
  • Packaging and shipping: the manifest contract, install and update under the supervisor, and marketplace submission with the 25/75 split.
  • Labs are now AI role-plays with named stakeholders, and the capstone is a scored artefact: a governed extension design with real code.
Outcomes

What you will be able to do.

  • You will be able to set up a Go module against Platform SDK v1.2.0 and construct a client from the supervisor's environment with sound transport and secrets handling.
  • You will be able to read, write and manage vault files, including images and documents, and choose correctly between direct writes and governed ingestion.
  • You will be able to call models through the LLM Registry with the Handler as default, ground answers in vault content with checked citations, and never default to a commercial model.
  • You will be able to use MCP tools, the integration catalog, OAuth bearers and Operator ENV credentials without storing or leaking secrets.
  • You will be able to apply policy checks, fail-closed role handling, audit events, notifications and namespace isolation inside an extension.
  • You will be able to classify SDK errors, set deadlines, retry only idempotent operations, and test extensions against httptest fakes.
  • You will be able to package, install, update and submit an extension, and record design decisions with record_decision during AI-assisted work.

Who it's for

  • Go developers building extensions that run on an organization's brain pod
  • Backend engineers at customer organizations automating work with institutional memory
  • Partner-firm developers building extensions for customers or for the bRRAIn Marketplace
  • Developers who already use bRRAIn through MCP clients and now need to build on the platform

Not covered here

  • Multi-system enterprise integration architecture (see Integration Engineer)
  • Platform architecture and multi-tenant design (see Platform Architect)
  • Operating pods, upgrades and governance administration (see the Operator and Controller tracks)
Syllabus

8 modules, 63 lessons.

About 18 hours of learning. Open a module to see every lesson.

  1. Platform SDK foundations: access, module and client 8 lessons · 2 h 15 min

    What the Platform SDK is and where extensions run, getting access through a developer seat, wiring the Go module, constructing the client from the supervisor's environment, and handling secrets and service identity.

    1. Module 1 pretest Diagnostic pretest · 5 min
    2. What the Platform SDK is, and where your code runs Reading · 15 min
    3. Getting access and wiring the module Worked example · 15 min
    4. Constructing the client and proving the platform is reachable Worked example · 15 min
    5. Secrets hygiene and service identity Reading · 15 min
    6. Scenario: choosing the right integration surface Scenario · 15 min
    7. Lab 1: bootstrap code review AI role-play lab · 45 min
    8. Module 1 retrieval check Retrieval check · 10 min
  2. Vault reads, writes and files 8 lessons · 2 h 15 min

    Reading text, JSON and binary files correctly, preparing images and documents, writing and appending safely with attribution, and managing files with an accurate model of delete.

    1. Module 2 pretest Diagnostic pretest · 5 min
    2. Reading vault files correctly Worked example · 15 min
    3. Working with images and documents Worked example · 15 min
    4. Writing and appending Worked example · 15 min
    5. List, stat, move, copy and delete Reading · 15 min
    6. Scenario: the vanishing drafts folder Scenario · 15 min
    7. Lab 2: vault operations review AI role-play lab · 45 min
    8. Module 2 retrieval check Retrieval check · 10 min
  3. Search, ingestion and tagging 8 lessons · 2 h 15 min

    Finding knowledge with Search, Grep and the search_vault tool as they behave on current pods, committing incoming content through policy-aware ingestion, tagging with POPE v1.1, and designing vault paths that respect namespaces and per-project permissions.

    1. Module 3 pretest Diagnostic pretest · 5 min
    2. Finding knowledge: Search, Grep and the search tool Worked example · 15 min
    3. Ingestion commit: governed writes for incoming content Worked example · 15 min
    4. POPE tagging at write time Reading · 15 min
    5. Designing where your extension writes Reading · 15 min
    6. Scenario: ingest or write? Scenario · 15 min
    7. Lab 3: ingestion design with a product owner AI role-play lab · 45 min
    8. Module 3 retrieval check Retrieval check · 10 min
  4. Models through the LLM Registry 8 lessons · 2 h 15 min

    Model selection with the Handler as default and commercial models as an organization's opt-in, single- and multi-turn calls, robust reply handling, grounded answers with checked citations, and image and document attachments.

    1. Module 4 pretest Diagnostic pretest · 5 min
    2. The LLM Registry and the Handler Reading · 15 min
    3. Calling models: single-turn, multi-turn and replies Worked example · 15 min
    4. Grounding answers in vault content Worked example · 15 min
    5. Sending images and documents to models Worked example · 15 min
    6. Scenario: "just use a commercial model" Scenario · 15 min
    7. Lab 4: designing a grounded answer feature AI role-play lab · 45 min
    8. Module 4 retrieval check Retrieval check · 10 min
  5. MCP tools, integrations and credentials 7 lessons · 2 h

    Calling the pod's MCP tools, reading the integration catalog and payload schemas, handling webhook subscription as it works today, and obtaining vendor credentials at call time through OAuth and Operator ENV.

    1. Module 5 pretest Diagnostic pretest · 5 min
    2. Calling MCP tools from an extension Worked example · 15 min
    3. The integration catalog, payload schemas and webhooks Worked example · 15 min
    4. Vendor credentials: OAuth bearers and Operator ENV Reading · 15 min
    5. Scenario: credential handling review Scenario · 15 min
    6. Lab 5: designing a connector-backed feature AI role-play lab · 45 min
    7. Module 5 retrieval check Retrieval check · 10 min
  6. Governance inside your extension 8 lessons · 2 h 15 min

    Policy checks with trusted identity, roles and the Control Plane as they behave today, audit events and notifications, and what namespace isolation and least privilege do and do not provide.

    1. Module 6 pretest Diagnostic pretest · 5 min
    2. Policy checks before you act Worked example · 15 min
    3. Roles, permissions and the Control Plane Reading · 15 min
    4. Audit events and notifications Worked example · 15 min
    5. Namespace isolation and least privilege Reading · 15 min
    6. Scenario: the role lookup that was never there Scenario · 15 min
    7. Lab 6: governance review with the Security Controller AI role-play lab · 45 min
    8. Module 6 retrieval check Retrieval check · 10 min
  7. Errors, resilience and testing 8 lessons · 2 h 15 min

    Classifying SDK errors, deadlines and safe retries with backoff, testing against httptest fakes that reproduce current-pod behavior, and debugging extensions on a pod.

    1. Module 7 pretest Diagnostic pretest · 5 min
    2. The error model: APIError, transport errors and validation errors Worked example · 15 min
    3. Deadlines, retries and backoff Worked example · 15 min
    4. Testing against a fake platform with httptest Worked example · 15 min
    5. Debugging an extension on a pod Reading · 15 min
    6. Scenario: duplicate lines after a retry storm Scenario · 15 min
    7. Lab 7: incident triage with an operator AI role-play lab · 45 min
    8. Module 7 retrieval check Retrieval check · 10 min
  8. Packaging, shipping and AI-assisted development 8 lessons · 2 h 15 min

    The manifest contract, packaging, install and update under the supervisor, marketplace submission and maintenance, recording decisions in AI-assisted sessions, and the capstone.

    1. Module 8 pretest Diagnostic pretest · 5 min
    2. The extension manifest Worked example · 15 min
    3. Packaging, install and update under the supervisor Reading · 15 min
    4. Marketplace submission and maintenance Reading · 15 min
    5. Recording decisions in AI-assisted development sessions Worked example · 15 min
    6. Scenario: release day Scenario · 15 min
    7. Module 8 retrieval check Retrieval check · 10 min
    8. Capstone: ship a governed digest extension AI role-play lab · 45 min
Labs and capstone

Practice against someone who pushes back.

Labs run in your browser as AI role-plays. An AI plays the person on the other side of the scenario — with their own goals and objections — and your work is scored against the published rubric. There is nothing to install.

  • Lab 1 · Platform SDK foundations: access, module and client

    Code review of an extension bootstrap with a tech lead who pushes back on the changes you propose (AI role-play)

  • Lab 2 · Vault reads, writes and files

    Review of a pull request adding attachment handling, with its author defending the code (AI role-play)

  • Lab 3 · Search, ingestion and tagging

    Designing email-attachment ingestion with an operations product owner (AI role-play)

  • Lab 4 · Models through the LLM Registry

    Designing an 'ask this project' feature with an engineering manager proposing unsafe shortcuts (AI role-play)

  • Lab 5 · MCP tools, integrations and credentials

    Defending a connector-backed feature's credential design to a Security Controller (AI role-play)

  • Lab 6 · Governance inside your extension

    Governance review of a 'retire digest' feature with a Security Controller (AI role-play)

  • Lab 7 · Errors, resilience and testing

    Incident triage with a pod operator after a bad release (AI role-play)

  • Lab 8 · Packaging, shipping and AI-assisted development

    Building and documenting a governed shift-handover extension for a fictional logistics customer (artefact, AI-scored)

Capstone

Ship a governed digest extension

Artefact submitted in the capstone lab, AI-scored against the published rubric

Pass mark: 72%

Scored on

  • Client, configuration and secrets15%
  • Vault and ingestion correctness20%
  • Model use and grounding15%
  • Governance: policy, audit, notification, namespace, least privilege20%
  • Errors, resilience and tests15%
  • Packaging, release and decision record15%
Exam and credential

One exam. A credential anyone can verify.

The exam

Items per form
59
Time allowed
120 min
Pass mark
72%
Performance tasks
4
Attempts included
2
Wait between attempts
7 days
  • Online and timed, taken on learn.brrain.io.
  • Your form is assembled for you from the course's item bank, so no two candidates sit the same paper.
  • Performance tasks are conducted by an AI examiner: you work through a realistic scenario and are scored against a published rubric.

The credential

  • A verifiable digital badge in your name.
  • A public verification page at learn.brrain.io/verify, so an employer or client can confirm it.
  • Valid for 3 years.
  • Renewal: At 3 years by passing the then-current exam
Before and after

Where this course sits.

Stacks well with

Questions

Frequently asked.

Do I need to install anything for the labs?

No. Labs and the capstone run in your browser on learn.brrain.io as AI role-plays: an AI plays the person on the other side of the scenario, and your work is scored against the rubric published with the course.

How is the exam delivered?

Online and timed: 59 items in 120 minutes, on a form assembled for you from the course's item bank. 4 of the items are performance tasks conducted by an AI examiner: you do the work rather than pick an answer. The pass mark is 72%.

What if I don't pass first time?

You have 2 attempts, with a 7-day wait after an unsuccessful attempt. Further exam attempts can be bought for $299 each.

How long is the credential valid?

3 years. You receive a verifiable digital badge with a public verification page at learn.brrain.io/verify, so anyone can confirm it is genuine.

I hold the v1 credential. Is it still valid?

Yes. Credentials earned on v1 remain valid and verifiable at learn.brrain.io/verify. When you renew, you sit the then-current version of the exam.

Can my company enroll a team?

Yes. Firms can buy a certification bundle for $2,999 per firm per year — see the pricing page — or contact us to arrange enrollment for a larger group.

Enroll

bRRAIn Certified SDK Developer

Build, test and ship governed bRRAIn extensions in Go with Platform SDK v1.2.0.