Skip to content
Blockchain Association of Cameroon
fr — Françaisen — English

Layer-0 Developer Academy

Curriculum map

A level is not a duration but a threshold: it is crossed on practical evidence, never on attendance. Each one states what the participant can do on the way out — and that statement becomes the marking scheme of the matching certification.

L014 workshops · 42 taught hours

Foundation — Beginner developer

The participant explains how a blockchain works without resorting to analogy, and verifies for themselves what an explorer shows them.

Audience

Complete beginners, students, career changers, technical public-sector staff.

Track

Covers

  • Internet architecture, networking, data structures, databases
  • Applied cryptography: hashing, signatures, Merkle trees
  • Distributed systems, fault tolerance, consensus families
  • Blocks, transactions, fees, wallets, nodes and validators

Exit criteria

  • 01Verify an inclusion proof without holding the full data set
  • 02Build, sign and get a transaction included on a test network
  • 03Describe the exact consequences of a compromised private key

BAC Certified Blockchain Foundations Associate

L120 workshops · 71 taught hours

Blockchain developer — Blockchain developer

The participant ships a chain-connected application that is tested, containerised and versioned — and knows what their code does not guarantee.

Audience

Practising developers and Level 0 graduates who want to ship applications.

Track

Covers

  • Linux, Git, containers and continuous integration
  • APIs, JSON-RPC, subscriptions and client resilience
  • Applied TypeScript, wallet connection, transaction tracking
  • Smart contracts: writing, testing, cross-auditing
  • Introduction to Rust (Substrate track) and Go (Cosmos track)

Exit criteria

  • 01Ship an application whose environment a peer reproduces from the repository alone
  • 02Audit a peer's contract and produce reproducible findings
  • 03Get a pull request merged after review by two reviewers

BAC Certified Blockchain Developer

L261 workshops · 228 taught hours

Appchain developer — Protocol developer

The participant builds a complete application blockchain and has another team reproduce it from the repository.

Covers

  • Chain specification, genesis state, multi-node network
  • Runtime or module engineering depending on specialisation
  • Chain economics: tokens, fees, staking, penalties
  • On-chain governance, upgrades and state migrations
  • Tests, simulation and execution cost measurement

Exit criteria

  • 01Deliver a chain where every call is tested and weighed by measurement
  • 02Carry out an upgrade against populated state with no downtime
  • 03Have a third-party team reproduce the entire network

BAC Certified Appchain Developer

L357 workshops · 213 taught hours

Infrastructure engineer — Blockchain infrastructure engineer

The participant operates a production infrastructure rebuildable from its repository, and proves its recovery times by timed drill.

Covers

  • Infrastructure as code, orchestration, public RPC service
  • Validator operations, session keys, double-sign protection
  • Observability, on-call, incident response and post-mortems
  • Backups, disaster recovery, capacity planning
  • Operated interoperability: relayers, light clients, bridges

Exit criteria

  • 01Rebuild a complete infrastructure after total destruction, within the committed window
  • 02Run a validator across a full era with no signing incident
  • 03Have a third party execute your operating procedures unaided

BAC Certified Blockchain Infrastructure Engineer

L418 workshops · 71 taught hours

Blockchain architect — Blockchain architect

The participant designs, costs and defends a production infrastructure before a technical and institutional panel, with a prototype in hand.

Audience

Senior engineers, technical leads, consultants and researchers.

Track

Covers

  • Founding decisions, consensus and execution-model choices
  • Simulated token economics and governance architecture
  • Scaling, data availability, zero-knowledge systems
  • Security architecture and multichain architecture
  • Institutional constraints, audit, reversibility

Exit criteria

  • 01Produce a costed architecture dossier defensible before a public client
  • 02Demonstrate feasibility by prototyping the riskiest component
  • 03Write a reversibility plan a client can hold you to

BAC Certified Blockchain Architect

The competency graph

Competencies, not courses, carry the prerequisites. A developer can therefore always see which prerequisite they are missing rather than which course to enrol in.

  1. L0 — 8 competencies

    • Networking and internet architecture

      Trace a request from DNS resolution to TLS handshake, and diagnose a connectivity failure.

      No prerequisite

    • Data structures and databases

      Choose between an ordered structure, a hash table and a tree based on the cost of the target operations.

      No prerequisite

    • Cryptographic primitives

      Correctly use hash functions, signatures and key pairs, and state what each one does — and does not — guarantee.

      Requires : Data structures and databases

    • Merkle trees and inclusion proofs

      Build a Merkle tree and verify an inclusion proof without holding the full data set.

      Requires : Cryptographic primitives

    • Distributed systems

      Reason about latency, network partitions and consistency, and situate a given protocol within that frame.

      Requires : Networking and internet architecture

    • Consensus theory

      Compare crash-fault and Byzantine-fault tolerance, and explain probabilistic versus deterministic finality.

      Requires : Distributed systems · Cryptographic primitives

    • Blockchain fundamentals

      Describe a transaction's lifecycle from wallet to finalised block, and read a block explorer critically.

      Requires : Merkle trees and inclusion proofs · Consensus theory

    • Key management and custody

      Generate, back up and rotate keys against an explicit threat model, including multisignature setups.

      Requires : Cryptographic primitives

  2. L1 — 8 competencies

    • Linux and the command line

      Administer a remote Linux server: permissions, services, logs, networking, package management.

      Requires : Networking and internet architecture

    • Git and open-source collaboration

      Contribute to a shared repository: branching, code review, conflict resolution, a readable history.

      No prerequisite

    • Containers and reproducible environments

      Package a service and its dependencies into a reproducible image and run it identically elsewhere.

      Requires : Linux and the command line

    • APIs, JSON-RPC and node integration

      Query a node over RPC, handle errors and rate limits, and build a reliable client over an unstable API.

      Requires : Networking and internet architecture · Blockchain fundamentals

    • JavaScript / TypeScript for Web3

      Build a typed front end that signs and tracks a transaction without ever handling the private key in the clear.

      Requires : APIs, JSON-RPC and node integration

    • Smart contracts (Solidity)

      Write, test and deploy a contract, and identify the most common vulnerability classes.

      Requires : JavaScript / TypeScript for Web3

    • Rust for protocol engineering

      Read and modify idiomatic Rust: ownership, borrowing, traits, explicit error handling.

      Requires : Git and open-source collaboration

    • Go for protocol engineering

      Write concurrent, tested Go: goroutines, contexts, interfaces, explicit error handling.

      Requires : Git and open-source collaboration

  3. L2 — 8 competencies

    • Node operations

      Launch, sync, supervise and restart a node, and read its metrics to anticipate a failure.

      Requires : Linux and the command line · Containers and reproducible environments · Blockchain fundamentals

    • Chain specification and genesis

      Author a complete chain specification and bootstrap a multi-node network from a controlled genesis state.

      Requires : Node operations

    • Runtime engineering (FRAME)

      Design a pallet: storage, extrinsics, events, hooks, errors, tests and benchmarked weights.

      Requires : Rust for protocol engineering · Chain specification and genesis

    • Module engineering (Cosmos SDK)

      Design a module: state, messages, queries, begin/end-block handlers, migrations, tests.

      Requires : Go for protocol engineering · Chain specification and genesis

    • Virtual machines and Avalanche L1s

      Deploy an Avalanche L1 and adapt a virtual machine to specific execution rules.

      Requires : Go for protocol engineering · Chain specification and genesis

    • Modularity and data availability

      Separate execution, settlement and data availability, and publish blobs verifiable by sampling.

      Requires : Merkle trees and inclusion proofs · Node operations

    • Sovereign rollup engineering

      Assemble a sovereign rollup: execution environment, data publication, fork-choice rules.

      Requires : Modularity and data availability · Rust for protocol engineering

    • On-chain governance and upgrades

      Carry an upgrade through a governance process without downtime or state loss.

      Requires : Chain specification and genesis

  4. L3 — 8 competencies

    • Validator operations

      Run a production validator: session keys, double-sign protection, failover, slashing monitoring.

      Requires : Node operations · Key management and custody

    • Cloud infrastructure and infrastructure-as-code

      Describe a node infrastructure as versioned code and rebuild it identically after total destruction.

      Requires : Containers and reproducible environments · Node operations

    • Observability and incident response

      Instrument metrics, logs and alerts, then run an incident through to a written post-mortem.

      Requires : Cloud infrastructure and infrastructure-as-code

    • Public RPC infrastructure

      Expose a public RPC service: load balancing, caching, rate limiting, isolation from consensus nodes.

      Requires : Cloud infrastructure and infrastructure-as-code · APIs, JSON-RPC and node integration

    • Protocol security

      Threat-model a protocol and assess the real cost of an attack on its consensus or governance.

      Requires : Consensus theory · Validator operations

    • Cross-chain messaging

      Establish a channel between two chains and trace a message end to end, including its failures and timeouts.

      Requires : Chain specification and genesis · Node operations

    • Light clients and relayers

      Explain what a light client actually verifies, and operate a relayer without granting it implicit trust.

      Requires : Cross-chain messaging · Merkle trees and inclusion proofs

    • Bridge security

      Classify a bridge by its trust assumption and map the major historical incidents onto that classification.

      Requires : Light clients and relayers · Protocol security

  5. L4 — 6 competencies

    • Protocol design

      Justify a choice of consensus, execution model and security model against real-world constraints.

      Requires : Runtime engineering (FRAME) · Module engineering (Cosmos SDK) · Protocol security

    • Token economics and incentives

      Model issuance, slashing and fees, and show that honest behaviour remains the rational strategy.

      Requires : On-chain governance and upgrades · Consensus theory

    • Governance architecture

      Distribute power between on-chain and institutional actors, emergency procedures included, without creating a permanent back door.

      Requires : On-chain governance and upgrades · Token economics and incentives

    • Zero-knowledge systems

      Situate validity and fraud proofs within an architecture, and state their verification cost.

      Requires : Cryptographic primitives · Sovereign rollup engineering

    • Multichain architecture

      Design a system spread across heterogeneous chains and document its trust boundaries.

      Requires : Bridge security · Cross-chain messaging · Protocol design

    • Enterprise and public-sector blockchain architecture

      Translate an institutional constraint — sovereignty, compliance, audit — into a defensible architecture decision.

      Requires : Multichain architecture · Token economics and incentives

Every concept, seven labs

The methodology applied across every track: a concept is not taught until it has been broken and repaired.

  1. 01LabDoes the concept work on a nominal case?
  2. 02Advanced labDoes it hold across several nodes?
  3. 03Infrastructure labDoes it hold on separate servers, under real network conditions?
  4. 04Security labWhat happens when an actor turns hostile?
  5. 05Failure labWhat happens when a component stops?
  6. 06Recovery labHow long does it take to return to service, and who knows how?
  7. 07Monitoring labWould the failure have been seen coming?

What every workshop page provides

The standard template no workshop may publish without.

  • Verifiable learning objectives
  • Explicit prerequisites, linked to the missing workshop
  • Theory and architecture diagrams
  • Demonstration and starter code
  • Guided lab and independent lab
  • GitHub repository with executable tests
  • Mandatory security challenge
  • Quiz and submitted assignment
  • Marking scheme and certification credits