Seeking Input: Developer Skill Pathways for DotCodeSchool

1

Hey everyone,

I’ve been reflecting on how to make DotCodeSchool more valuable to the community, and came across the idea of creating tailored skill pathways for different developer personas.

What is DotCodeSchool?

DotCodeSchool is an interactive learning platform aimed at helping developers build real-world Web3 apps, specifically within the Polkadot ecosystem. The goal is to make Polkadot development accessible to everyone — from beginners taking their first steps to experienced developers looking to deepen their knowledge.

DotCodeSchool emphasizes hands-on projects and practical applications rather than theoretical concepts alone. We believe that the best way to learn Web3 development is by building and experimenting with real tools and frameworks, just as you would in the field.

Why Skill Pathways?

Polkadot’s ecosystem is diverse and has room for developers from various backgrounds — each with unique skills, motivations, and learning preferences. Right now, the challenge is to provide structured, engaging guidance that meets the needs of each type of developer. Platforms like Codecademy use skill-specific pathways to increase engagement and success rates because they make learning feel relevant and progressively rewarding (progressive overload).

By creating dedicated learning paths for each developer type, we can leverage their existing skills while gradually introducing more complex concepts specific to Polkadot. I think this will make the onboarding process is smoother, more relevant, and ultimately more successful.

The Six Developer Personas

To make DotCodeSchool truly valuable, we need to recognize that not all developers are the same. Polkadot’s ecosystem attracts a diverse range of developers, each bringing unique skills, motivations, and goals. To create effective learning paths, I’m focusing on these six key personas:

  1. Frontend Developers: Focus on building interactive dApps with wallet integration and real-time data.
  2. Backend Developers: Create APIs and data services that interact with blockchain data.
  3. DevOps Engineers: Run and maintain nodes, ensure network reliability, automate updates and build monitoring systems.
  4. Smart Contract Developers: Build decentralized apps and services on Plaza or using Ink!.
  5. Core Blockchain Developers (Runtime, Pallets, Nodes): Develop custom pallets and parachain runtimes.
  6. Data Analysts and Indexers: Extract and analyze on-chain data for insights and dashboards.

Why Personalizing These Paths Matters:

By understanding each persona’s skills, motivations, and needs, we can make learning experiences that resonate, keep them engaged, and make the journey rewarding at every step. Instead of generic tutorials, we can offer progressive, hands-on projects that help them build real, “show-offable” applications on Polkadot.

This structured approach not only helps newcomers get started but also ensures that as they progress, they see clear, tangible growth in their skills — keeping them hooked on building with Web3 tech.

What I Mean by Skill Pathways:

image
image903×816 118 KB

When I say “skill pathways,” I’m not talking about building new tech features or complicated onboarding flows. I’m talking about writing well-crafted, carefully curated content that caters specifically to each developer type.

Focusing on making the learning process rewarding and practical by offering:

  • Quick wins: Low-commitment, instantly gratifying mini-projects (30min-1h).
  • Step-Up Challenges: Building on small successes to boost confidence (within a day or two).
  • Project Sprints: Practical applications to solidify concepts (1-2 weeks).
  • Advanced Exploration: Delving deeper into ecosystem-specific skills (time commitment here will vary based on user-specific interest).
  • Mastery Projects: Real-world, portfolio-ready applications (4-6 weeks).
  • Community Contribution: Encouraging learners to share their projects and insights (buildondot.com to list community vetted ideas, ecosystem bounties, polkadot-sdk issues, etc. for students to work on).

Request For Your Input:

I’d love your feedback on this idea to ensure we’re moving in the right direction. So here are my questions to you:

  • Does this approach make sense to you?
  • Do you think it will be valuable to the community?
  • Which top three pathways should I focus on first, and in what order?
  • Would you like to contribute or share your own learning experiences?

PS - I’d also like to make an open call for community contributions.

DotCodeSchool is fully open-source, and we’ve recently revamped our publishing system to support MDX tutorials and articles. You can now include interactive features like quizzes, making it easier than ever to contribute content and make learning engaging. Here’s a quick video demonstrating just how easy it is now:

https://x.com/i/status/1920064594082742526

If you’re interested in contributing in any way to this effort, I would love to hear from you. Your contributions can help shape the future of how developers learn and build on Polkadot and they will directly shape the direction of DotCodeSchool.

If this speaks to you, please do reach out to me directly on Telegram: Contact @batmancodes

9 Likes
2

Hi @batman,

This approach makes 101% sense to me! :raising_hands:

I truly believe this will be incredibly valuable to the community — speaking from personal experience, I remember when I first tried to integrate a wallet connect feature into my dApp. It took me 2–3 hours just to find the right approach. If DotCodeSchool had a tutorial for that back then, it would’ve saved me so much time — so for newcomers, having guided pathways like this would be a game-changer.

In terms of prioritization, I’d suggest starting with:

  1. Frontend Developers – since many newcomers are eager to get something visual working quickly.
  2. Backend Developers – to complement the frontend and teach how to handle blockchain data.
  3. Smart Contract Developers – because once people are comfortable with dApps, they naturally want to explore the logic behind them.

And yes, I’d love to contribute! I’m excited to help make DotCodeSchool the go-to place for newcomers to the Polkadot ecosystem.

Let me know how I can help :raising_hands:

3

If you wish to contribute, I think you could start with the problem you described here:

Perhaps you could write an article/short course teaching newcomers how to do this?

You can use this to get started: frontend/content at master · dotcodeschool/frontend · GitHub

Feel free to reach out to me if any of the contribution guidelines/processes to be unclear, buggy or difficult.

4

Glad to see dotcodeschool advancing, becoming more open and helping developers get into the ecosystem in a structured way.

I love the idea of skill pathways. We have so many ways to develop on polkadot, even the papermoon docs clearly separate paths like parachains and smart contracts.
I love that we’re adding frontend to the mix, to showcase how building good interfaces with our tools can be easy and help more people create those.

While I do find some developer personas like devops to be very interesting, I would prioritize frontend and smart contracts as those are the things we expect to see a lot of in the Hub.

I’d also love to contribute! Keep up the good work

2 Likes
5

Thank you for your support @francisco.aguirre! I tend to agree that frontend seems to be the best starting point based on the feedback so far. It’s clear that focusing on quick-win projects and gradually scaling to more complex ones is the way to go.

So, the plan from here is to move fast and iterate later. I’d rather have an imperfect path that we can refine based on real feedback than spend too long planning upfront.

Next Steps:

  1. I’ll come up with a set of specific frontend tutorials, starting with small, practical projects that can be completed quickly.
  2. Once I have a draft of the frontend skill path, I’ll share the overview here on this forum post to gather feedback before finalizing.
  3. Based on the feedback, I’ll refine the path and move forward with creating and publishing the tutorials.

I really appreciate your willingness to contribute! Let me know if you have any ideas on how we could make it easier or more appealing for yourself (or anyone else) to get involved. Your input would be super valuable, whether it’s about content ideas or improving the contribution process.

Also, whenever you have time, I’d love to hear your feedback on the tutorials as they come out.

Please don’t hesitate to reach out to me if you run into any hiccups when publishing a tutorial or have any suggestions along the way.

6

Great work on DotCodeSchool @batman ! Yeah i agree with the others, these paths type would make a lot of sense, with a focus on creating real applications and not just simple exercises, thats how you really learn something !

1 Like
7

Progress Update #1

First Skill Pathway in the Works — DotPets

Just wanted to share a quick update on the skill pathways initiative I mentioned earlier.

I’m currently working on the first pathway — targeted primarily at frontend/Web3-curious developers who want to get a feel for Web3 without needing to dive deep into runtimes, pallets, or smart contracts right away.

The project I’m anchoring this around is called DotPets — a tamagotchi-style on-chain pet game built using Polkadot Asset Hub and Polkadot-API.

The goal is to create a fun, lightweight entry point into Web3 that also teaches real fundamentals — wallet connection, on-chain state, identity, and asset minting using Polkadot’s Asset Hub + Polkadot-API.

In my head, it’s like the Substrate Kitties Course — but for frontend devs.

What the First Tutorial Will Cover

The goal of the first tutorial is to give developers a quick, satisfying win by walking them through:

  • Connecting a Polkadot wallet to a frontend app
  • Querying on-chain state (e.g., checking account balance or existing NFTs) using Polkadot API (PAPI)
  • Minting a unique NFT (your DotPet) on Asset Hub
    • This is where we’ll introduce the concept of extrinsics — what they are, why they’re called that, and how signed transactions affect chain state
  • Viewing the NFT on Subscan or another explorer

Where Things Are At

I’m currently building out the project myself — making sure it’s intuitive, enjoyable, and insightful before turning it into a tutorial.

Once the flow feels right, I’ll shape it into a step-by-step guide to kick off the first DotCodeSchool skill pathway.

:artist_palette: Help Wanted: Pet Artwork

I’d love to include some 2D game-style visuals to bring the pets to life.

If you:

  • Know any AI tools for generating consistent 2D game artwork
  • Or are a designer/artist and want to collaborate on visuals

…please reach out! I’m especially looking for a way to create assets that feel cohesive across pet types and states (e.g., mood changes or evolutions).

Even tool suggestions would be appreciated.

Thanks again to everyone who contributed ideas in the original thread — this is starting to take shape, and I’m excited to keep building it with (and for) the community.

2 Likes
8

Hey, @batman

There is a good compilation of smaller lessons (quick wins that you mentioned) on Polkadot.Study.

They have different tags for their lessons, so it is easy to group lessons for each developer’s taste. Actually, they already have 2 study paths (Substrate and Polkadot.js).

They also integrated Substrate in Bits and Substrate Tutorials as separate tabs. I think, it is a really good thing to have interoperability between study materials.

You can get inspiration from this website and their tracks, maybe even copy some of the tutorials. Some of them may be outdated as the courses haven’t been updated for months. But yeah, unification and consolidation of study materials would be beneficial for the community.

I may help with Core Blockchain Track. Just need to find some time and review the materials.

1 Like
9

Yeah I agree @luzanikita. Polkadot.Study was a solid resource.

Like you pointed out, the main problem is the outdated content, but I’m on the same page regarding taking inspiration from there.

Substrate in bits is a good inspiration for the first step (“quick win”), but it’s important to also keep in mind that we follow it up with next actionable step (i.e. build the skill pathway) to retain users all the way till they can contribute something meaningful to the ecosystem.

So, the idea isn’t necessarily to have a bunch of disconnected quick win tutorials, but rather a vertically aligned path that leads to direct contribution to Polkadot.

Hence, ideally at the end of the skill pathway, we will point them to open issues on the polkadot SDK repo + some real world project ideas on buildondot.com (also needs updating).

But, the critical constraint with these dev onboarding efforts remains. That is keeping the content:

  1. Fresh and updated
  2. Engaging and fun

So, I really appreciate your offer to help with the Core Blockchain Track and would encourage you to perhaps start with a small article — that way you can get something up without too much time commitment initially and even gauge response from the community.

As always, if you have any questions or face any issues while trying to write or publish a tutorial on dotcodeschool, please don’t hesitate to reach out to me.

1 Like
10

:waving_hand: initator of polkadot.study and frontend tutorial author here,

The lesson I learned from creating it is that even though there was funding available for authors (1500$ for a tutorial) it was hard to find them. I have the impression that curating authors and or even having in house authors for different tracks is a thing that is one of the most important aspects of founding a tutorials platform. Did you think about funding for authors? From my current point of view creating engaging tutorials (+videos) is difficult and needs lots of considerations as well as work afterwards on maintainance as you say. Shawn’s kitties tutorial really stands out here. Maybe creating a track “frontend” and then collecting ideas in on tutorials in the forum that authors can try to write.

I can imagine writing frontend tutorials or parts of them. I think building a full production ready application is a good content, that can be split in different modules each one concentrating on a specific lection in frontend dev with Polkadot (wallet connection, reading chain state / mutating chain state, subscriptions, …). I also hope that initiatives like a UI Component Library can reduce much boilerplate code for frontend developers. In my tokengated-next-js-tutorial a huge part was setting up contexts and providers for that purpose. That way tutorials would become easier for starters and better to maintain by outsourcing logic and ui to other libraries (papi, reactive-dot, ui-component-lib).

Thank you for picking up the mission of providing good developer tutorials for Polkadot.

2 Likes
11

thanks for the comment @niklasp!

my personal view is that someone has to be employed full-time in house for this (ideally multiple devs) — it is very much an active role and anyone who’s working on something else will inevitably have shifting priorities and this can easily take a backseat.

someone needs to be going out and hosting meetups more or less every month (if not every week) and constantly gathering feedback and improving the content until we have something very solid which only requires updates once a year or so (which shouldn’t be awfully difficult i believe).

given that, if we have clear content, we need to encourage more people to present it in their local communities and share their workshop results in a specific format — ideally including video recordings. Such efforts imo should be rewarded heavily based on outcomes.

one of the key problems is that some of the devs who are capable of doing this and possibly even want to do it have higher priorities to deal with and often the kind of effort a truly good tutorial like substrate kitties requires, $1500 probably just doesn’t cut it.

i believe the incentives need to be well-structured for something like this to work… quoting the abstract from Pay Enough or Don’t Pay at all research paper:

Economists usually assume that monetary incentives improve performance, and psychologists claim that the opposite may happen. We present and discuss a set of experiments designed to test these contrasting claims. We found that the effect of monetary compensation on performance was not monotonic. In the treatments in which money was offered, a larger amount yielded a higher performance. However, offering money did not always produce an improvement: subjects who were offered monetary incentives performed more poorly than those who were offered no compensation. Several possible interpretations of the results are discussed.

hence, if we truly want good developer documentation, we need to pay people well - the barrier to a tutorial being accepted should be high and should be rewarded heavily when it is accepted. i would even argue that $30k per course (that’s similar to substrate kitties) may be where the incentives actually become lucrative and probably $10k for something smaller (the size of PAPI tutorial) and even the good articles (similar to substrate in bits) need to be around $2500 a pop.

that’s where i think the incentives would be of any use and i’m not sure how willing the treasury would be to provide such funding to any initiative outside of the PBA, but i think there’s a case to be made for creating a bounty where the right people (imo @shawntabrizi and @kianenigma) are the initial curators and they can appoint people they deem fit to judge the tutorial quality to delegate this responsibility and free themselves from the day to day of this role.

but so long as the incentives aren’t there, i would argue we should have no incentives at all and people who wish to contribute should do so as a passion project.

1 Like
12

Tbh we pay 100k each year for a gif on coingecko, we can spend more on education …

2 Likes
13

(I’m not involved in marketing or education, no dog in either of these races, but…)
(A) it’s my understanding that the CG campaign was not limited to the gif
(B) do you know how much we spend each year on education (it’s a lot more than 100k…)

1 Like
14

Yeah it wasnt limited to the gif, but the gif itself is 100k a year which i find ludicrous

image
image1179×631 67.6 KB

Yeah we spend a lot on education with PBA. I feel like we have a big issue on retaining people after PBA tho… i think this has to do with how hard it is to find a job in the ecosystem.

1 Like
15

Progress Update #2

Just wanted to share a quick WIP update on the first DotCodeSchool skill pathway: DotPets

What’s done (but needs polish)

  • What is a blockchain? Covered as a tamper-evident linked list, then distinguished from a blockchain network - in hindsight, this should probably be a standalone article.
  • Project initialization with PAPI
    • What PAPI does
    • Why it’s useful for frontend-first Web3 dev
    • How chain specs work and how to generate types
  • User authentication (wallet connection)
    • How Web3 auth works without a backend
    • Why this model respects user privacy and removes infra dependencies
  • Querying user balance
    • How to use Smoldot + PAPI to query live balances
    • Still need to explain why light clients like Smoldot matter for censorship-resistant frontends

What’s next

I’ll be working on the NFT minting flow next:

  • How to use the Uniques pallet to create NFT collections (nfts pallet felt slightly complex for this)
  • Why we’re storing pet metadata on IPFS
  • The importance of pinning for persistence

Meta update:

Progress has been slower lately since I’m also job hunting to sustain myself, and reworking parts of the flow/scope as I go. I want this to be actually useful and fun to build, not just a checklist tutorial.

I’ll be taking a short break from this specific work for a week or two to allow ideas around the course structure to flow, but I’d love your feedback or contributions in the meantime.

Content suggestions, structural feedback, or frontend best practices everything is welcome and encouraged.

Thanks for all the support so far — still early, but it’s taking shape.

2 Likes