PTM EDV-Systeme GmbH
Mohammad Alabbasi, Junior Software Developer bei mscrm-addons.com
Description
Mohammad Alabbasi von mscrm-addons.com erzählt im Interview über seinen Werdegang als Developer, was das Besondere an seiner Arbeit ist und gib nützliche Hinweise für Neueinsteiger.
By playing the video, you agree to data transfer to YouTube and acknowledge the privacy policy.
Video Summary
In Mohammad Alabbasi, Junior Software Developer bei mscrm-addons.com, Mohammad Alabbasi shares his path from Iraq to Austria, studying computer science at Graz University of Technology, and joining PTM 1.5 years ago as a junior back-end developer working with seniors on bug fixes and new features. Starting with no industry experience, he learned Selenium for UI testing and progressed from small tasks and test projects to contributing to production code under close mentorship. His advice: begin with an accessible language like Python, focus on core concepts, practice small projects, engage with communities and documentation, keep yourself updated, and be patient—programming feels complex at first but becomes powerful once you grasp it.
From Python Beginnings to Production Code: Mohammad Alabbasi’s Journey at mscrm-addons.com (PTM EDV-Systeme GmbH)
Context and Session
Title: Mohammad Alabbasi, Junior Software Developer bei mscrm-addons.com
Speaker: Mohammad Alabbasi
Company: PTM EDV-Systeme GmbH
We listened to Mohammad Alabbasi recount a grounded developer journey that moves from zero industry experience to shipping backend changes in a real product. He’s originally from Iraq, has lived in Austria for about seven years, studies computer science at Graz University of Technology, and works as a Junior Software Developer at mscrm-addons.com (PTM EDV-Systeme GmbH).
The arc he describes is honest and repeatable: start where you are, lean on your seniors, build testing muscle at the UI layer with Selenium, and then grow into backend responsibilities—one ticket at a time. The themes are simple, but powerful: understand concepts, practice in small steps, read documentation, join communities, and above all, be patient.
“Be patient … programming in the beginning is just complicated. But when you understand it, it is very powerful.”
Who is Mohammad Alabbasi?
- Origin: Iraq
- In Austria: about seven years
- Studies: Computer Science at Graz University of Technology
- Role: Junior Software Developer at mscrm-addons.com (PTM EDV-Systeme GmbH)
Mohammad leaned into software development a little over three years ago. About a year and a half ago, he joined PTM EDV-Systeme GmbH and entered his first professional engineering team. His story is about showing up every day for a product that initially felt complicated—and steadily building the mental model to navigate it.
Joining PTM EDV-Systeme GmbH: A junior in a learning-friendly setup
Mohammad works within team groups and collaborates closely with multiple senior developers, primarily with his supervisor, Martin. That daily proximity to senior experience is a core accelerant of his growth.
“As a junior developer, I work along with senior developers, with my supervisors … I work with my supervisor, Martin.”
His work centers on a practical mix: fixing bugs and building new features for their applications. For a junior, it’s the right split—diagnose issues in existing logic, then carry new functionality into a living product.
“Fixing bugs, doing new features for our applications.”
Why this task mix matters
- Bugfixes immerse you in how the system actually behaves—edge cases, constraints, historical context.
- Small features build confidence and end-to-end ownership.
- Continuous feedback from seniors turns confusion into clarity without wasted cycles.
First projects: UI testing with Selenium
Mohammad’s starting line wasn’t backend; it was UI quality. Early on, he learned Selenium and helped build two UI testing projects to validate their applications’ user interface.
“When I started, actually, we built a few UI testing projects. So I had to learn Selenium as a testing tool … And then we built actually two cool projects for testing the UI of our applications.”
Why UI testing is a smart entry point
- It exposes you to the product exactly as users experience it.
- You learn flows and failure modes without immediately parsing the entire codebase.
- Automated tests cultivate scenario thinking: preconditions, inputs, and expected outputs.
UI testing gave Mohammad visible outcomes and a sharpened sense of how the application is supposed to behave. That understanding underpins productive backend work later on.
From first tickets to production code
Mohammad is candid about those early days: he joined with no prior professional development experience; the product felt complex; progress came in small, structured steps.
“When I joined, actually, I had no experience in software development … First, I had to learn what actually our company is doing … first, it was very complicated, actually. But then, day after day, you learn … step by step, you get tasks. First, easy tasks. And then you develop yourself … and then you get into the really … production code.”
This shape of growth is instructive:
- Orientation: understand the product, domain, and team processes.
- Small tasks: low-risk entries with quick feedback loops.
- Mentoring: pair with seniors, ask questions, read code together.
- Responsibility: gradually move into production-impacting changes.
Mentoring as a force multiplier
Mohammad’s repeated mention of senior developers is telling. Reviews, pairing, and clear points of contact compress learning time. They also make it easier to ask questions and course-correct quickly.
Today: Backend focus with real impact
Mohammad now operates on the backend, where correctness and stability have immediate consequences—data, rules, and flows converge here. The work remains a blend of bugfixes and features, but with deeper system responsibility.
“Currently, I'm working as a junior developer, a back-end developer.”
The learning principles powering his progress
We valued how direct Mohammad’s advice is: no buzzwords—just repeatable practices that compound.
1) Start with a beginner-friendly language
“Start with a beginner-friendly programming language, like Python.”
Python is emblematic of what matters early: fast feedback and clear syntax that let you internalize core programming ideas—variables, control flow, data structures, functions, modules. Mastering those makes future languages and frameworks easier to adopt.
2) Prioritize concepts over syntax
“Focus on understanding the concepts of programming … it's really important to understand the concepts first.”
Concepts form durable knowledge:
- Abstraction and modularity
- State and data structures
- Control flow, iteration, recursion
- Interfaces and contracts
- Testability and maintainability
Syntax can be looked up; mental models cannot be outsourced.
3) Practice through small projects
“Of course, practicing, doing small projects first. And then you go on from there.”
Small projects offer:
- Manageable scope, so finishing is realistic.
- End-to-end exposure—from idea to result, including debugging.
- Clear feedback—what works, what doesn’t, and why.
4) Engage with online communities
“Maybe also engage into online communities, for example.”
Communities give you answers and also a sense of practical norms: how others structure code, test, and reason about trade-offs. Learning speeds up when you learn together.
5) Read documentation and stay up to date
“Update yourself always. Read documentations for the programming languages and so on.”
Documentation is a time-saver. It shows intended usage, lists edge cases, and often reveals features that elegantly solve your problem. Staying current isn’t hype—it’s tool stewardship.
6) Patience: the curve flattens
“Programming … in the beginning is just complicated … when you understand it … it is very powerful.”
Early on, everything feels dense: terms, tools, errors. Patience isn’t passive—it’s disciplined daily effort. Over time, understanding compounds, and decisions become clearer and faster.
Why this path works
Mohammad’s trajectory validates patterns we’ve seen across high-functioning teams:
- Quality-first entry: UI testing with Selenium provides product intuition and structured thinking.
- Embedded mentorship: senior proximity turns ambiguity into learning.
- Task progression: from safe, small changes to production-critical work builds confidence and ownership.
- Study-work synergy: academic learning and industry practice reinforce each other when real requirements shape what you learn next.
Quotes worth remembering
“First, I had to learn what actually our company is doing … first, it was very complicated, actually. But then, day after day, you learn.”
“We built actually two cool projects for testing the UI of our applications.”
“Step by step, you get tasks. First, easy tasks … and then you get into … production code.”
“Start with … Python … focus on understanding the concepts … practicing … engage into online communities … read documentations … be patient.”
Actionable steps for junior developers
- Pick one beginner-friendly language and commit to it for months.
- Practice daily with small, finishable tasks—shipping beats perfection.
- Read the docs deliberately; bookmark examples and try them.
- Join a community where asking questions is safe.
- Proactively seek feedback from senior developers.
- Accept initial complexity—consistency turns confusion into clarity.
The sequence matters: from UI tests to backend work
Mohammad’s path illustrates a helpful order of operations:
- Start by understanding the product from the outside with UI tests.
- Move into backend via bugfixes—debugging forces deep understanding.
- Grow into features—translate requirements, extend the system, own outcomes.
That sequence scales; many juniors can replicate it.
Team dynamics: groups and a clear supervisor
Mohammad points out that the dev teams are divided into groups and that he primarily works with one senior supervisor. That’s more than org structure—it’s a learning design. A consistent point of contact reduces friction, while access to “two or three senior developers” broadens perspective.
“The dev teams is also divided into groups … I work with my supervisor, Martin … and, you know, fixing bugs, doing new features …”
A realistic take on the beginning
There’s no sugarcoating in Mohammad’s account. A real product can feel “very complicated” at first. The antidote is progressive exposure: small tasks, steady mentorship, and patience. That honesty sets healthy expectations for anyone entering their first developer role.
What we’re taking away from this session
- Learning is daily compounding: “Day after day, you learn.”
- Good teams build learning curves: clear seniors, right-sized tickets, frequent feedback.
- Testing as an entry point is smart: Selenium-based UI testing connects product intuition with disciplined scenario thinking.
- Fundamentals beat hype: concepts, documentation, practice, patience.
- Responsibility grows with practice: from the first bugfix to production code in the backend.
Conclusion: A quiet, steady success story
The session “Mohammad Alabbasi, Junior Software Developer bei mscrm-addons.com” doesn’t celebrate a meteoric rise. It celebrates consistency: moving from Iraq to Austria, from the classroom to a professional team, from UI testing to backend development—anchored in learning, mentorship, and patience.
For us, that’s the essence of a sustainable developer start: realistic steps, continuous practice, and the willingness to understand a little more of the system every single day.
“Programming … for me, is just a skill. When you get it, when you understand it, then it is very powerful.”
Internalize that, and you’ve already covered meaningful ground.
