Founded 2020 · Zaječar, Serbia

We didn't build a video agency. We built the studio that should have existed already.

Lumaris Studio is run by engineers who got tired of watching technically wrong videos represent technically brilliant products. The team that makes your videos has written the same kind of code you're building. The first draft is technically accurate. Your engineers stay on product.

Book a 15-min call See the work

Currently producing for active retainer clients. Two calibration slots open this month. The founder reviews every audit personally.

Marko Živić, Founder of Lumaris Studio, former GitHub Actions Team Lead

The commit history of a studio built by engineers.

$ git log --graph --pretty=format:'%h %s · %ad' --all

Before a single video was produced, there were ten years of engineering. Marko Živić spent that decade as a senior developer, Team Lead, and Product Owner, writing production code, managing engineering teams, and shipping software to enterprise clients. He learned how software is actually built, not how it's explained in a demo.

// stack acquired over a decade
roles = ["Product Owner (IBM, Terra Cloud)", "Team Lead (GitHub Actions)", 
         "Senior Developer (Euronext, Paceteq, Crayon, Exlrt)"]
domains = [".NET", "JS", "TypeScript", "SQL", "DevOps", 
           "CI/CD", "API design", "Microservices", "Distributed systems"]

While reviewing vendor-produced videos for technical products from the inside, Marko noticed a pattern: almost every video had errors. Wrong syntax. Inaccurate commands. Misleading architecture diagrams. Or video was just improssible to follow along. The companies making these videos were not incompetent, they were competent videographers. The problem was structural. They didn't understand the technology they were filming.

editor.skill = "cinematography"
editor.skill += "storytelling"
// but critically:
editor.skill += "how your code actually works"  // ← missing

The fork wasn't to become a videographer. It was to build the studio that should have existed already. One where the editors have programming backgrounds, every script is verified by developers before a frame is touched, and the structural claim "video editors who write code" is a literal description of the team, not marketing copy.

The first retainer client validated the premise immediately. The brief went in. The editor read the codebase. No briefing call required. First draft delivered. Zero revision rounds on technical accuracy. The client shipped a video explaining their product to a developer audience and every claim in it was correct.

client            = "Code with Antonio (420K subscribers)"
syntax_errors     = 0
revision_rounds   = 0
engineering_hours = 0
status            = SHIPPED

200+ technical videos delivered. Zero syntax errors across every deliverable. Two verified Clutch reviews (Antonio · 5.0/5.0, Thu Vu · 5.0/5.0). Eight active retainer client. Four calibration slots open this month. The studio built to fix a structural problem in technical video production is now the proof the problem is fixable. And that the fix holds at scale.

// the record stands. the guarantee holds.

The problem

Technical video production is structurally broken.

It's not that video production companies are bad at their jobs. It's that the job was defined wrong. Great cinematography and great technical understanding are treated as separate disciplines. They are not separate - they are inseparable. When an editor doesn't understand your product, the revision cycle becomes a tutoring session.

Your engineers spend hours explaining what a Dockerfile is. Your PM manages feedback rounds that should never have existed. Your content calendar slips. And the developer audience watching the final video can tell something is off, even if they can't explain what.

OBSERVABLE SYMPTOMS

A senior engineer pulled into "quick technical review." Again.
"Can you explain what this terminal command does?" for the fifth time.
Draft 1 returns with 40+ comments. Draft 3 is still not right.
The video ships two weeks late. The next one is already behind.
The developer audience notices something's off, but can't articulate it.
Six months in, the channel goes dark. No one writes a retrospective.

This isn't a process problem. It's a hiring problem the rest of the market refuses to fix.

The solution

Hire the engineers first. Teach them video second.

We didn't hire videographers and train them in technical products. We hired people with programming backgrounds and trained them in production. The sequence matters. Someone who has used Kubernetes, read API documentation, and debugged a CI pipeline approaches a technical brief differently from someone who just learned what those words mean. The result isn't fewer revision rounds. It's a different production process, one where accuracy is built in, not checked for at the end.

01 / 03

The editor opens the repo before the script.

Every project starts with documentation review and, where available, repository access. The editor understands the product at the code level before the first word of script is written. By the time a kickoff call happens, the editor is asking architectural questions, not asking what your product does.

02 / 03

A separate dev team checks every technical element.

A development team member, not the editor, reviews every code snippet, terminal command, and architecture diagram before you see the cut. Errors are caught at the production stage, not the revision stage. The output is the Dev Validation Receipt that ships with every video.

03 / 03

Find a technical inaccuracy, your next video is free.

The technical accuracy guarantee isn't generous. It's structurally safe to offer because the validation process makes it nearly impossible to violate. 200+ videos delivered. Zero invocations. The guarantee is public because the system is verified.

Building the team

We hired engineers who wanted to make videos. Not videographers who needed to learn code.

The distinction sounds subtle. In practice it's the difference between an editor who asks "what's a container registry?" and one who already knows, and flags when your Dockerfile example won't actually work in the environment you're describing.

Every team member can read production code.

Not "understand tech concepts." Read, run, and verify actual production code. That's the baseline requirement, not a differentiator. Every editor, every script writer, every motion designer on this team has cleared it.

CI/CD. DevEx. API auth. Observability.

We've produced content across every major domain developer tools companies operate in. When a new client comes in, the onboarding is calibration, not education. We already know the domain. We're learning the product.

You talk directly to the editor.

On the Growth tier and above, there's no account manager between you and the person making your video. Direct communication means faster context transfer, fewer misunderstandings, and no phone-tag with someone who wasn't on the last call.

I didn't leave engineering to run a video agency. I left because I watched technically brilliant products get killed by content that looked polished and was factually wrong. Developers noticed. Comment sections turned hostile. Marketing teams stopped trying. Engineering teams blamed marketing. Nobody fixed the root problem. Lumaris is what fixing it structurally looks like.

Marko Živić Founder, Lumaris Studio Former GitHub Actions Team Lead · IBM Product Owner

$ validate --target=code-snippets
  Checking 14 code blocks against compiler...
  ✓ All 14 blocks: syntax valid

$ verify --target=terminal-commands
  Running 8 commands in isolated env...
  ✓ All commands: exit code 0

$ check --target=architecture-diagrams
  Cross-referencing against client system docs...
  ✓ 3/3 diagrams: architecturally accurate

$ verify --target=api-references
  Checking against live docs at time of production...
  ⚠ 1 endpoint path updated in latest release
    ↳ auto-corrected: /v2/review → /v3/review

$ generate --output=validation-receipt
  ✓ Validation complete: 1 correction applied
  ✓ Draft cleared for client delivery

// the client never saw the API path issue.

This runs on every deliverable. Not on request. Not on complex projects. On everything.

The people

The team behind your videos.

01

Marko Živić - Founder & CEO

GitHub Actions Team Lead · IBM Product Owner · Senior Engineer at Euronext & Paceteq · Founded Lumaris 2020

Marko spent a decade writing production code before picking up a camera. That decade isn't backstory, it's the product. Every system Lumaris has built (the validation pipeline, the briefing process, the guarantee, the hiring criteria) is a direct output of watching technical video production fail from inside the companies it was supposed to serve.

He leads every client relationship at the Foundation tier and reviews technical validation across all engagements. When a client's codebase lands in the intake form, Marko reads it. Not out of obligation, because that's how the first brief gets written without a briefing call.

Led engineering teams across CI/CD, DevEx, enterprise API, and cloud infrastructure
Designed the internal validation system that has produced zero technical errors across 200+ videos
Personally reviews every Free Video Audit submission

Ljubica Živić, Co-Founder and Creative Director of Lumaris Studio

02

Ljubica Živić - Co-Founder & Creative Director

Creative Direction · Motion Design · Brand Systems · Co-Founded Lumaris 2020

Ljubica owns the creative output. Every visual system Lumaris produces, from the motion design language to the way technical diagrams are animated and paced against code walkthroughs, runs through her. Technical accuracy and visual quality are not in tension in her work. They are the same standard.

The creative direction at Lumaris is built on a single principle: a technically wrong visual is a bad visual, regardless of how polished it looks. Ljubica reads a brief for accuracy before she reads it for aesthetics.

Leads creative direction across all retainer engagements, including product demos, tutorials, explainers, and brand content
Built the motion design system from the ground up, with no stock templates; every animation is custom-built for the product
Co-responsible for the visual accuracy standard: every architectural diagram Lumaris produces is both correct and clear

The Lumaris Studio team in Zaječar, Serbia, 200+ technical videos produced with zero syntax errors — // LUMARIS STUDIO TEAM · 2026 · 200+ VIDEOS · ZERO SYNTAX ERRORS // Zaječar, Serbia

Two spots currently available

Work with a team that already understands your product.

No pitch deck. A direct conversation about what you're producing now, what isn't working, and whether we're structurally the right fit. The first 15 minutes are diagnostic. If we're not the answer, we'll say so on the call.

Book the 15-min call Start with a free audit first

currently producing for 8 active retainer clients

4 calibration slots open this month

founder reviews every audit submission personally

response within 24 hours