DEV Community: cursora

What a coding education platform actually looks like after 6 months of building (screenshots, no mockups)

cursora — Mon, 20 Jul 2026 19:29:34 +0000

Building in public, screenshots included

I work on cursora, a coding education platform. Landing pages tend to oversell — so instead of another feature list, here's what the product actually looks like right now, straight from the running app.

The catalog

27 published courses live today, spanning web, backend, DevOps and more. No "coming soon" placeholders in the grid — these are courses students can start immediately.

The instructor editor

Courses are built section by section, lesson by lesson, with a live "readiness" score so instructors can see how close a course is to publish-ready before it goes live. Our own DevOps course is sitting at 90% readiness as I write this.

The sandbox

This is the part I actually care about explaining. Coding exercises don't run in a fake terminal — each one spins up an isolated container with:

A real base image (alpine:3.20 for this exercise)
Explicit CPU limits (0.5 cores here) and a memory ceiling per container
A configurable execution mode — VM-isolated workers for the heavier exercises
Network access set to none by default — no external calls in or out
An optional setup script (plain bash) that provisions the environment before the student's first command

Students run real commands — docker version, docker info, whatever the exercise calls for — against a real environment, not a canned output.

Cursora Assess

For instructors who still want traditional graded tests alongside the hands-on exercises, there's Cursora Assess: generate printable/online test variants, auto-grade scanned answer sheets via OCR, and get a stats/report view per group.

Where it's at

669 learners, 27 courses, and a platform that's still very much being built in the open. If you're curious what practical, hands-on coding education infrastructure looks like under the hood, take a look: cursora.org. Happy to answer questions about the sandbox architecture specifically — that's the part I'd most like feedback on.

I Built a Platform Where Anyone Can Publish a Coding Course Today — No Approval Process

cursora — Mon, 20 Jul 2026 05:36:36 +0000

Why I'm writing this

I work on cursora, a coding education platform. We're trying to grow the course catalog, and instead of a polished landing page pitch, I'd rather explain honestly what it actually is — and ask this community to poke holes in it.

The premise

Most "become an instructor" flows on ed-tech platforms involve an application, a review queue, and a wait. Ours doesn't. If you're logged in, you can start building a course right now at cursora.org/my/teaching — no approval gate.

What you actually get

A content editor with full control over your material — text, images, video, code
Real code execution sandboxes for 13 languages (Python, JS/TS, Go, Rust, Java, C/C++, and more)
Challenge types beyond multiple-choice: Linux/CLI challenges, MongoDB challenges, CSS challenges, and full project-based tasks
Cursora Assess, a proper tool for testing and grading students — not just a quiz widget
Full control over your course's price and content

What's honestly still missing

I'm not going to oversell this: we don't have a slick, fully worked-out payout/commission system yet. That part of the platform is still evolving. If your main motivation is monetizing a course today, it's fair to wait. If you like teaching and want a place to publish something more interactive than a slide deck or a YouTube playlist, it's worth a look.

Why hands-on matters to us

The platform's whole premise is that people learn by doing, not by watching. So the course-authoring tools are built around that: real sandboxes instead of video-only lessons, real challenge types instead of just quizzes.

If you want to try it

Start here: cursora.org/my/teaching. No form, no waiting on someone's approval queue. Happy to answer hard questions in the comments — including "why would I use this over [X]."

Your Team Has an Internal Onboarding Doc for Juniors? That's Already 80% of a Course

cursora — Sat, 18 Jul 2026 06:25:10 +0000

If you've ever onboarded a junior on your team, you probably have a doc — or three — sitting in Confluence, Notion, or some private repo, explaining how your team does code review, how to set up the dev environment, what mistakes to avoid, what your commit convention looks like. That knowledge lives in an internal wiki and never leaves it.

That's exactly the kind of material that turns into a course.

The gap between "internal doc" and "course" is smaller than it looks:

A text doc → a lesson with tables, code blocks, and Mermaid diagrams if you're explaining architecture or a data flow.
"Try setting this up and let me know how it goes" → a code challenge that actually checks whether the student can do it, run in a sandbox in one of 13 supported languages — no more "done ✅" on Slack, the result gets checked automatically.
Your three most-repeated pieces of code review feedback → a standalone lesson on the mistakes you always see from new hires.

You don't need to start from zero and invent a curriculum. The material already exists — it just needs to come out of the internal wiki, get organized, and turn into something someone outside the company can work through too.

Bonus: next time you hire a junior, you can send a link instead of explaining the same thing live all over again.

Set up an instructor account on cursora.org — see how much of what you already know and already have written down turns into a first lesson in under an hour.

Want to Actually Master a Technology? Start Teaching It to Someone Else

cursora — Thu, 16 Jul 2026 10:27:13 +0000

You know the feeling: you think you understand something well, right up until you have to explain it to someone else. Suddenly "well, it just works that way" isn't good enough, and you start noticing gaps you never saw while you were only using that knowledge for yourself.

That's not a coincidence — it's one of the best-documented ways to deepen a skill: explaining something simply enough for a total beginner to follow forces you to find and patch your own gaps. Teaching isn't a side effect of expertise — it's one of the tools you use to build it.

Which is why creating a course on cursora.org doesn't have to be purely "share what you know with others" — it's also a solid way to close your own gaps.

What that looks like in practice:

You write a lesson about something you "know" — and along the way you catch yourself unable to explain in two sentences why something works the way it does. That's a signal to go check it properly before you finish the lesson.
You build a code challenge — a task the student has to solve on their own in one of 13 supported languages, actually executed in a sandbox. Designing a good challenge forces you to break a problem down into concrete, checkable steps, not just "and then you just do it."
You get questions from learners that you would have eventually asked yourself, if you'd had someone to check with.

Side effect: you end up with a public, concrete proof of competence — something you can point to on a résumé or portfolio instead of just writing "I know Python" with nothing behind it.

You don't need to be a senior engineer with a decade of experience to start. You just need to know something better than someone who's just starting out — which describes almost anyone who writes code at all.

Set up an instructor account on cursora.org and see how fast you can publish your first lesson. Worst case, you walk away understanding your own subject better than you did going in.

Been Coding in Production for 5+ Years? That Knowledge Is Worth More Than You Think — Turn It Into a Course

cursora — Wed, 15 Jul 2026 18:37:57 +0000

You've spent years writing code that actually ships. You've seen what a real code review looks like, what a real production incident looks like, the real "why this behaves differently than the tutorial said." That's knowledge you won't find in a free YouTube course — and yet every day someone starts learning to code from material that simply doesn't have it.

That's exactly the gap cursora.org is built to fill — and exactly why it's worth creating an account there, whether you want to learn or to teach.

Why it's worth signing up as a learner

Because the gap between "I watched a video about React" and "I wrote and ran 20 React challenges, in a sandbox, with real feedback" is enormous. On cursora, you don't click "next episode" — you write code in one of 13 supported languages (Python, JavaScript, TypeScript, Java, C, C++, C#, Bash, PHP, Go, Rust, Ruby, Kotlin), it actually compiles and runs in an isolated Docker environment, and you get a real result. Nothing to install locally, no "works on my machine." On top of that there are Linux challenges (a real system sandbox, not a quiz) and CSS challenges with visual-diff rendering checks — things a typical video course simply doesn't have.

Why it's worth signing up as someone who teaches

This is where it gets interesting. If you have real experience in your field — developer, DevOps, sysadmin, someone who actually knows databases or testing — you can turn that experience into income instead of keeping it locked inside your own team.

What you actually get as an instructor:

Full control over price and content — you decide what you teach and what it costs, not the platform.
Real content-building tools, not a bare text editor: tables, LaTeX for formulas, Mermaid diagrams, embedded code playgrounds, embedded audio/PDF/video — you can build a lesson that actually looks and works like real technical documentation, not a slide deck.
Gradebook and QR attendance if you run a cohort or in-person class — no duct-taped spreadsheet.
Cursora Assess to build printed and online tests when you need to formally verify understanding, not just check off lesson completion.
Student communication tools and detailed sales and progress stats — you know exactly where people get stuck in your course, and you can fix it.
Technical and marketing support, plus a community of other people who teach — you're not doing this alone.

This isn't another platform full of throwaway courses

Cursora isn't built for "record a video, upload it, forget it." It's built for people who want their students to actually be able to do something after the course, not just watch someone else do it. That's what separates courses people finish from courses that get abandoned at 12% — and that matters to you as a creator just as much as it matters to the people paying for your course.

What's next

If you're learning — go to cursora.org, browse the catalog, and try the first lesson for free, no card required.

If you have experience worth sharing — check out the Instructor Zone, create an account, and see how fast you can publish your first lesson. It takes minutes, and the knowledge you've built up over years of real work is exactly what someone out there is looking for.

13 Languages, Sandboxed Code Challenges, Real Projects — What Practical Coding Education Actually Looks Like

cursora — Tue, 14 Jul 2026 12:32:36 +0000

Most coding courses end the same way: you watch a video, retype the code on screen, get marked "completed," and... nothing sticks. No muscle memory, no confidence you could write it again without the tutorial open in another tab.

We're building cursora.org to fix that — a platform where learning means actually writing and running code, not watching someone else do it.

What actually sets cursora apart from another video course:

Code challenges in 13 languages — Python, JavaScript, TypeScript, Java, C, C++, C#, Bash, PHP, Go, Rust, Ruby, Kotlin. Your code runs for real, inside an isolated, network-less Docker sandbox — safe, and nothing to install locally.
Linux and CSS challenges — an interactive system sandbox and visual-diff rendering checks, not just multiple-choice theory quizzes.
Lessons built by practitioners — a rich editor with tables, LaTeX, Mermaid diagrams, embedded code playgrounds, audio/PDF/video embeds.
Gradebook, QR attendance, completion certificates — if you're teaching a cohort or running a class, you get real tooling for it, not a duct-taped spreadsheet.
Cursora Assess — build printed and online tests when you need to formally check understanding, not just track lesson completion.

You can start for free, no card required.

If you'd rather learn by doing than by watching — head to cursora.org, browse the public course catalog, and try the first lesson for free. And if you teach programming yourself, setting up an instructor account takes about a minute.

How We Safely Run User Code in 13 Languages

cursora — Fri, 10 Jul 2026 17:45:52 +0000

If you're building a coding education platform, sooner or later you hit the question: how do you run a STRANGER's code without risking the rest of your system? At Cursora we solved this for 13 languages — from Python to Rust and Kotlin — and wanted to share how it works under the hood.

The problem

A student submits code. It needs to compile (or not), run, accept input, and return output — all within a few seconds, safely, for thousands of runs a day. The naive approach (eval() or a bare subprocess on the host) is a fast track to disaster: unrestricted network access, filesystem access, CPU/RAM.

Our approach: container-level isolation

Every code run goes into its own, ephemeral Docker container with:

network: none — zero network access, so even a malicious attempt has nowhere to "phone home" to
hard memory, CPU, and process-count (PID) limits — tuned per language (compiled languages like Java or Rust get higher floors than lightweight interpreters)
the container destroyed immediately after the run — no persistent state between attempts

For compiled languages (Java, C, C++, C#, Go, Rust, Kotlin) we first build the binary inside that same isolated, network-less environment, then run it — so the code can only ever use the standard library, no external packages or crates.

What about the live terminal?

A separate challenge is our Live Programming module — a multi-file interactive editor with a real terminal (XTerm.js) wired over WebSocket. Here the container needs to live longer than a single invocation — it's a long-lived, stateful TTY session that our code-executor's session manager keeps separate from the ephemeral test runs.

Why this matters if you're learning

This architecture lets you write, compile, and run real code — Python, JavaScript, TypeScript, Java, C, C++, C#, Go, Rust, Ruby, PHP, Kotlin, Bash — directly in your browser, with nothing to install locally, and we can guarantee your code will never put you or other learners on the platform at risk.

Want to try it yourself? cursora.org has hands-on programming courses with real projects and code challenges across all of the languages above.

Why We Think Coding Education Should Be More Hands-On

cursora — Fri, 10 Jul 2026 11:29:43 +0000

Most programming courses follow the same pattern: watch a video, read some slides, maybe answer a multiple-choice quiz. You finish feeling like you learned about code — not that you can actually write it.

That gap is why we built cursora.

What's different

Real code, not video playback. Every course includes live coding environments, interactive terminals, and auto-graded challenges — you write and run actual code from the first lesson.
Project-based learning. Instead of isolated exercises, you build things: small apps, scripts, full projects that mirror what you'd actually ship at work.
Learn at your own pace. No cohorts, no deadlines. Come back after a week or a month — your progress is right where you left it.
Broad language support. Python, JavaScript/TypeScript, Java, C/C++, Go, Rust, Bash, PHP, Ruby, Kotlin — pick what's relevant to you.
Instant feedback. Code challenges run in sandboxed containers and give you real output, real errors, real learning — not just a green checkmark.

Who it's for

Whether you're starting from zero or leveling up a specific skill, cursora is built around the idea that you learn to code by coding — not by watching someone else do it.

We're just getting started, and we'd love feedback from the dev.to community — what's worked (or hasn't) in your own learning journey? What would make a platform like this actually useful to you?

👉 Check out the course catalog