PTM EDV-Systeme GmbH
Christoph Kokely, Senior Software Developer bei mscrm-addons.com
Description
Christoph Kokely von mscrm-addons.com spricht im Interview über seine Anfänge mit dem Programmieren als Kind bis hin zu seiner aktuellen Arbeit und gibt Tipps für Beginner.
By playing the video, you agree to data transfer to YouTube and acknowledge the privacy policy.
Video Summary
In "Christoph Kokely, Senior Software Developer bei mscrm-addons.com," Speaker: Christoph Kokely traces his path from growing up with a programmer father and 286-era PCs through hobby projects and business informatics to early gigs (Access UIs, QA data capture at VW Mandl und Berger) and the late-90s/2000s boom in custom software, progressing from junior to senior. He emphasizes that seniority comes from experience and foresight—coding less but knowing more—and advises starting as a junior, caring about maintainable code you can still read in 10 years, and mastering fundamentals (algorithms, data structures, program flow) and English by solving problems that matter to you.
From a 286 to Senior Developer: Christoph Kokely on passion, fundamentals, and writing code you’ll still understand in ten years
The Devstory in context: What this session is about
In our DevJobs.at Devstory titled “Christoph Kokely, Senior Software Developer bei mscrm-addons.com,” Speaker Christoph Kokely (Company: PTM EDV-Systeme GmbH) walks us through his developer journey—from a curious kid in front of a “huge gray box” to a Senior Engineer who “drinks coffee and knows things.” What stands out is how practical and grounded his story is. No buzzwords, no silver bullets—just honest lessons earned through years of coding, failing, understanding, and coding again.
Kokely’s narrative is a reminder that there are no shortcuts in software development. It starts with curiosity, grows through projects that genuinely matter to us, and matures into a mindset that values quality over cleverness. That mindset, we learn, is the true differentiator on the path from junior to senior.
Early imprint: Curiosity, family, and a 286
Christoph Kokely didn’t stumble into technology by accident. His father was a programmer as far back as the 1960s. That proximity opened a door early—and he stepped through it. He paints a vivid picture: at home, suddenly there’s a “huge gray box.” It was the time when the 286 was “the hot thing.” Games? “So bad” that programming became the more interesting alternative almost immediately.
He stayed glued to that machine—longer than one might consider healthy at that age, as he jokes. What mattered was access and the ability to ask questions. Hours became days and years. From that came the inner drive that shapes his career: a desire to understand technology properly, not superficially.
Education with intention: AHS, business informatics, work on the side
Passion turned into a path. Kokely attended an AHS and chose informatics “wherever possible.” Then came university, studying business informatics. More important than the stations themselves is what he did with them: coding on the side, project-based work, always picking tasks he found interesting. Because:
“If you have a project you enjoy, you learn a lot.”
That simple formula—interest plus doing—runs through his journey. It also explains why treating programming purely as a job rarely leads to excellence: passion isn’t a luxury; it’s a learning accelerator.
First steps: Hobby projects, Access forms, real clients
Like many of us, he started with hobby projects. Games kept him engaged—not as a consumer, but as someone who “wanted to build it myself.” He poured in “a lot of sweat,” spent hours frustrated, and kept learning. Hobbies led to the first paid gigs: user interfaces “back then with Microsoft Office Access,” wired up to databases. Projects grew, as did the demands—technically and financially.
A key milestone was his first side job at VW Mandl and Berger. There he developed quality assurance software for data capture. It’s the moment when personal competence and market need meet: what he had taught himself solved a real problem.
Entering the profession: Custom software around the millennium
After university came “the big working life.” The timing is notable: in the late 1990s and early 2000s, demand for bespoke software was huge. Kokely gained a foothold quickly. He emphasizes there was “always something to do”—but also strong competition. In that environment, what counts is not a single masterstroke but steady improvement and a willingness to take responsibility.
Experience accumulated. With it, the focus of his work shifted—from straightforward implementation to estimation, structuring, and thinking ahead. The move toward the senior role wasn’t a ceremony; it was the sum of many choices and learning loops.
What seniority means: “You drink coffee and know things”
Kokely sums up the senior role with a grin:
“You drink coffee and know things.”
The Game of Thrones nod is funny—and accurate. The core is serious: seniority is foremost about experience. It’s the ability to anticipate impact, to see where “pulling a thread” in code ripples through the system. It’s better estimation, better judgement. And it doesn’t materialize overnight; it’s “the arduous, rocky path through the junior developer” phase.
Once you arrive there, you “see the big picture”—and that’s when projects become truly “cool”: architecture and codebase converge by design, and you’re not just building—you’re safeguarding.
Craft over cleverness: Code you can still read a decade from now
One of the session’s strongest points addresses our collective weakness for the cleverest solution. Kokely reframes it:
“The coolest solution isn’t always the best. The best is the one where I can look at the code in ten years and still understand it.”
That’s the heart of it: readability, maintainability, changeability. Not a one-off “stroke of genius” by your younger self, but a system of decisions that is sturdy today and tomorrow. For him, this is the essence of being a senior developer:
- Write code that can be reused.
- Build a shared codebase that benefits others.
- Take responsibility for future-proofing—not just today’s ticket.
We take this as a clear stand against short-term brilliance and for sustainable software quality.
From tools to theory: Why fundamentals are the constant
Another major theme is how learning should be approached. Programming languages are tools. They do jobs—and they change. “Every few years,” something comes along that does the same job, perhaps better. What remains are the fundamentals:
- Algorithms and data structures
- How programs work “under the hood”
- How data is modeled, moved, and processed
Kokely admits that this can be “incredibly dry”—but it’s non-negotiable. If you grasp the foundation, you adopt new languages faster, design sturdier systems, and make good decisions beyond fashion cycles. For beginners, his advice is direct: focus on understanding “how the whole thing works.”
English as a tool: Vocabulary over grammar
His take on language is pragmatic: programming is English—“through and through.” Good vocabulary helps immediately; perfect grammar is secondary. If you can consume documentation, error messages, and community posts in the original, you avoid translation pitfalls. It’s a simple lever for everyday speed and quality.
Passion as a learning engine: Choose problems you truly care about
Most developers know this instinctively: you learn the most when you can’t put a problem down. Kokely confirms it through his own practice. For him, games were the initial trigger—not playing them, but the urge to “build it myself.” That intrinsic motivation made “a lot of sweat” bearable and productive.
His recommendation is clear: pick something that genuinely interests you, and try to solve it. That’s what creates the hours where real expertise compounds—long before a job title acknowledges it.
The path: First junior, then senior—automatically? In principle, yes, but…
Kokely encourages everyone to start as a junior developer—“pretty much the most important first step.” If you’re in it “with heart and soul,” the senior role follows “in principle, automatically.” The crucial ingredient is attitude: a “heart for code” and genuine attachment to the product. The point isn’t that it happens on its own; it’s that passion plus time plus practice stacks up to experience—and that’s what makes the difference.
Bridging school and industry: What we learned
We found Kokely’s balance especially useful:
- Education provides the foundation: theory, concepts, systematic thinking.
- Practice provides the feedback: which concepts hold, where the limits are, where compromises matter.
- The senior role emerges when both strands grow together over years—fueled by curiosity, projects, and responsibility.
His tongue-in-cheek remark about the duration—coding “for nearly 40 years… rounded up”—shows how long these arcs can be. The exact number matters less than the message: experience is time with substance.
Architecture in the small: Seeing effects before they happen
A recurring image in the session is “pulling a thread” in code. It’s about the cascading effects we all know: a seemingly minor change breaks something elsewhere. Seniority means spotting these chains before they snap. That requires:
- Awareness of dependencies across the codebase
- Understanding data flows and side effects
- Willingness to think systemically, not just locally
This perspective isn’t reserved for architects. It starts with every merge request, every refactoring, every new function. You develop it by taking responsibility—and learning from the outcomes.
Making quality visible: Maintainability as a team sport
Kokely’s emphasis on maintainable code is also a team message. A “shared codebase” means that today’s commit is tomorrow’s reading material for a teammate. Making maintainability visible means prioritizing clear interfaces, sensible names, and solid abstractions—over the trick that saves time today and costs double tomorrow.
In practice, that looks like:
- Consistent, meaningful naming
- Preferring simple structures over tangled “cleverness”
- Minimizing side effects; making dependencies explicit
- A review culture that values readability and changeability as quality metrics
None of this is new—what separates seniority from “good enough” is the consistency with which you apply it.
Competing markets that make you better
Kokely describes the early 2000s as a time of “incredibly high demand” for custom software—with strong competition. To us, that’s a template for today: new domains open, demand exists, many want in. To thrive, you don’t need a trick—you need a toolkit of fundamentals, pragmatism, and a commitment to quality. That’s what his career exemplifies.
Starting routes for juniors: What we recommend, distilled from the talk
From Kokely’s experiences, we distilled concrete steps for getting started:
- Build your learning base
- Truly understand algorithms, data structures, program flow.
- Practice systematically: small projects, finished well.
- Strengthen your English
- Vocabulary is your daily tool: docs, errors, forums.
- Perfect grammar is secondary—comprehension is key.
- Pick projects that matter to you
- Choose a topic that grabs you. That keeps you in the game when it gets hard.
- Define goals, measure progress, ship.
- Embrace the junior role
- Ask questions, seek feedback, take responsibility.
- Favor readability and maintainability over “smart” one-offs.
- Let experience compound
- Repeat, deepen, reflect. Seniority is an outcome, not a target.
These steps are demanding, but they pay into the account from which you later draw as a senior: the ability to anticipate impact, make good trade-offs, and build durable systems.
Short quotes, long reach
Three lines from this Devstory deserve a spot on any team wall:
“You drink coffee and know things.”
“The coolest solution isn’t always the best… I want to understand it in ten years.”
“A programming language is a tool… algorithms and data structures are the foundation.”
Together, they sketch the path from “I write code” to “I build enduring systems.”
Why this story resonates with developers
Christoph Kokely’s account isn’t glossy or heroic. It’s normal—in the best way: start curious, pick projects, endure frustration, learn, ship, repeat. That’s why it resonates. It encourages us to move patiently and to take the right things seriously: fundamentals, language, teamwork, responsibility.
From the session “Christoph Kokely, Senior Software Developer bei mscrm-addons.com,” we at DevJobs.at take away a mindset more than a method: seniority is the consequence of passion, practice, and the will to write code you can still understand a decade from now. That’s the kind of professionalism teams can rely on and careers can grow from.
Conclusion: Seniority is craft, attitude, and time—compounded
Christoph Kokely (Speaker: Christoph Kokely; Company: PTM EDV-Systeme GmbH) shows what matters in software development—and what remains when fashions change:
- Passion accelerates learning.
- Fundamentals outlast tooling cycles.
- Maintainability beats short-term cleverness.
- Experience anticipates consequences and protects the codebase.
In short: you become a senior by doing the right things long enough, the right way. If you’re starting today, these principles are your best compass—from your first hobby project to stewarding a shared codebase with your team.
