fiskaly GmbH
Kostas Plakidas, Back End Developer bei fiskaly
Description
Kostas Plakidas von fiskaly spricht im Interview über seinen Werdegang – angefangen bei Turbo Pascal bis hin zu seiner aktuellen Arbeit – und gibt Tipps für Anfänger.
By playing the video, you agree to data transfer to YouTube and acknowledge the privacy policy.
Video Summary
In 'Kostas Plakidas, Back End Developer bei fiskaly', Speaker Kostas Plakidas charts his path from tinkering with Turbo Pascal at 16, through electrical engineering and a CS PhD in Austria, to backend work at fiskaly using Go alongside Java/TypeScript on Google Cloud Platform. He moved from more abstract academic research (Python, R) to industry to tackle real problems, building a cloud-based fiscalization solution that cryptographically signs receipts to prevent later changes and fight tax fraud. He outlines operational complexity—edge cases, detective-style debugging, and certified components that require months-long recertification—driving architectural trade-offs; his advice is to learn by doing, stay open and collaborative, and recognize that newcomers from diverse backgrounds can succeed.
From Turbo Pascal to Cloud Fiscalization in Go: The Developer Journey of Kostas Plakidas, Back End Developer at fiskaly GmbH
A grounded story about curiosity, constraints, and craft
In the session “Kostas Plakidas, Back End Developer bei fiskaly,” Speaker Kostas Plakidas from fiskaly GmbH traces a path many engineers will recognize: tinkering at a home PC, a university phase packed with languages and theory, a stint in research—and a decisive move into industry to solve problems that bite back. His narrative is a lesson in how playful curiosity matures into a pragmatic engineering mindset: hands-on, constraint-aware, and relentlessly learning.
We recap what stood out to us—from early experiments and academic breadth to cloud operations, certified components, and advice for beginners—always through the lens of what developers can apply today.
Teenage beginnings: games, questions, and a Turbo Pascal disk
Kostas’ story starts with a simple why: How do the things I use on a PC actually work? At 16, already playing computer games, he finds an installation disk for Turbo Pascal. He starts “playing” with it—writing small applications to test “what is possible on my home PC.”
- First tool: Turbo Pascal
- Root motivation: pry open the inner workings of software
- Learning mode: experiment first, learn by doing, ship small
Many careers begin here: no formal plan, lots of intrinsic motivation, visible results fueling the next loop.
University: from electrical engineering to computer and information sciences
Kostas began as an electrical engineer, but a wider realization took hold early: programming languages are not only “the future”—they empower other sciences. At university he worked with C++, Java, Fortran, VHDL, and Assembly. The range broadened his view across paradigms and abstraction layers that now inform his architectural thinking.
He noticed that software and programming helped other sciences—and decided to study computer and information sciences.
The degree delivered robust mental models—math, algorithms, ideas about software architecture. But Kostas remained clear-eyed about the limits of theory: it’s only one side of the craft.
Greece, Austria, a Ph.D.—and then a turn back to industry
After some time working in Greece, Kostas moved to Austria for a Ph.D. in computer science. Nearing completion, a decisive impulse took over: return to industry.
Research is “very fun,” he notes, and he used languages like Python and R to solve technical problems. But it tends to be “a bit abstract and theoretical.” He wanted something “more demanding,” where he could learn, solve problems, and face challenges.
He wanted to “go back to industry and do something that is more demanding,” to solve real problems and keep learning.
That decision brought him to fiskaly GmbH, where he started as a back-end developer—and encountered new languages, including Go, which is now the team’s main programming language.
Why fiskaly GmbH? Variety, learning, and real-world impact
Kostas points to a “large variety” of reasons: technical offerings, different programming languages, and a place where you can learn. The common thread is growth in the presence of real constraints—making trade-offs, choosing options, and keeping long-term maintainability in view.
- Polyglot stack: Go as the main language, with Java and significant TypeScript
- Cloud infrastructure: resources on Google Cloud Platform
- Learning grounds: architecture decisions, operations, real-world edge cases
For Kostas, professional growth means doing the work where it counts—inside systems with consequences, where engineering is as much about judgment as it is about code.
The product domain: fiscalization as a “noble cause”
fiskaly’s product domain is fiscalization: digitally stamping and encrypting receipts so they cannot be altered after the fact. The aim is straightforward and socially valuable: fight tax crime.
“Our product is fiscalization… receipts are digitally stamped and encrypted, and they cannot be changed afterwards.” It’s “a very valuable and noble cause.”
That mission is both meaningful and technically demanding: you operate within strict requirements, underlining the need for careful architecture and operational discipline.
From a local component to the cloud—what got better (and what got harder)
Kostas outlines the evolution: the product they developed for the German market started as a local solution. Besides the cash register, there was an additional component—“both hardware and software.” In terms of security and maintenance, “a bit of a nightmare.”
They moved the concept to the cloud for “a much more elegant solution.” But cloud operations create their own category of challenges: ongoing maintenance, distributed complexity, and failure modes that span components and time.
- Local: extra hardware/software component, heavy maintenance/security burden
- Cloud: elegance and centralization, but more system dynamism and operational complexity
He sums up the reality of production succinctly: even if you have a solution that works really well, the live operation is “a huge beast,” developing its own momentum over time, with “unforeseen edge cases.”
Debugging as detective work: embrace the edge cases
When customers do something unexpected, you need to figure out what happened—quickly. That demands habits and skills that go beyond single services.
“You have to play a bit of a detective.”
Kostas’ approach emphasizes breadth and anticipation:
- Build experience across all components of the system
- Think ahead: consider problems before they happen—and treat that as part of the job
- Keep options on the table and decide with a long-term view
This is the posture of mature back-end engineering: hypothesis-driven debugging, clear instrumentation, and practical fixes that fit the system’s constraints.
Certified components: when a bug persists—and you must still deliver
A defining constraint in fiscalization: some components are certified. You cannot change them freely. If a bug is found there, you have to “request a certification process,” start it, and go through all its steps—“which can take a few months.”
“You can’t really touch them until they are certified.”
Meanwhile, the bug exists—and customers need a working system. That’s where, as Kostas puts it, “the fun begins”: you find mitigation strategies in other components without violating strict requirements.
- Operating with strict requirements: regulatory expectations shape architecture
- Strategy: mitigate outside the certified parts, design for workaround paths
- Trade-offs: always choose options with long-term value while solving the immediate issue
Architecture here is pragmatic: it’s about the ability to act within constraints while keeping the system coherent.
Architecture as long-game decision-making
Kostas highlights the habit of “having options on the table and choosing between them,” explicitly with an eye to long-term outcomes. In practice that includes:
- Designing clean interfaces so fixes can land where change is permitted
- Accepting workarounds that respect requirements—and folding them into cleaner fixes later
- Balancing a polyglot implementation: Go at the center, with Java and TypeScript where appropriate
- Leveraging cloud resources (Google Cloud Platform) as needed
In regulated domains, this mix of discipline and adaptability is essential. Short-term patches are fine—if they harmonize with the architecture and set up future improvements.
Stack and tools: Go at the core, plus Java, TypeScript, and GCP
Kostas is explicit about the stack:
“Most of our components are built in Go, but we also use Java, a lot of TypeScript, and of course the infrastructure and resources of Google Cloud Platform.”
And he frames the environment as rich with opportunity:
He could work “three, four years” without exhausting the “options and possibilities”—and “that’s the fun.”
The message for developers is clear: there’s room to specialize and room to explore—from service design in Go to cloud operations and the edges where observability meets architecture.
Advice for beginners: do more, worry less, stay open
Kostas’ entry into programming recalls a different era: to learn, you’d get books and read them. Today, newcomers have Google, Stack Overflow, YouTube—the challenge is not scarcity, but abundance. His advice is refreshingly simple:
- The options are many—and that’s good. Try things. Discover what you like: back end, front end, game development. Just start doing it.
- There are no formal requirements to begin, beyond community and the willingness to try things.
- University is valuable—math, algorithms, and architectural ideas—but there is no substitute for hands-on practice: sit at your PC and try things.
- In the long run, cultivate the will to learn, be open about what you don’t know, accept it, and collaborate with others.
Kostas underscores how diverse backgrounds strengthen engineering teams:
Some of the best people he worked with came from fields like oriental studies (Arabic and Sumerian) before moving into programming—and they were great.
His conclusion is inclusive: software is open to everyone and can be combined with almost any other science—geology, biology, history—you name it.
Practical takeaways for developers
What can back-end engineers, SREs, and aspiring developers apply right away from “Kostas Plakidas, Back End Developer bei fiskaly”?
- Cultivate detective habits
- Edge cases are normal. Observe, hypothesize, measure, and narrow down.
- Build broad system knowledge: data flows, state transitions, dependencies, and certification boundaries.
- Treat architecture as options management
- Empower change where regulated parts cannot be touched.
- Plan workarounds that respect requirements and fold them into cleaner fixes later.
- Be polyglot, but keep a center of gravity
- Go as a robust main language, complemented by Java and TypeScript where they fit.
- Use Google Cloud Platform as a toolbox—know the options, pick only what you need.
- Respect theory, prioritize practice
- Models and algorithms matter.
- Progress happens at the keyboard: prototypes, measurements, iterations.
- Make learning routine, not an event
- The motivation to “learn things” drives sustained growth.
- Reviews, knowledge sharing, and post-incident learning strengthen the detective mindset.
- Keep an open, collaborative mindset
- Different academic and professional backgrounds add real strength.
- Admitting what you don’t know is the starting point for teamwork.
What we learned from “Kostas Plakidas, Back End Developer bei fiskaly”
Kostas’ journey isn’t a strict career template; it’s an engineering posture:
- Start with curiosity, and keep it alive.
- Use theory—but let practice decide.
- Build systems you can operate under real constraints.
- Treat edge cases as learning signals, not annoyances.
- Choose options that work today and won’t block you tomorrow.
Fiscalization sharpens these habits: certified components, strict requirements, and a mission to prevent fraud demand discipline. Moving the concept to the cloud offers elegance and scale, while surfacing new operational challenges. The work is to embrace both truths.
A note on joy: the fun of the inexhaustible
Kostas’ remark that he could work “three, four years” without exhausting the “options and possibilities” captures a quiet joy: software is an open field. For those who want to learn, there’s always a new angle where practice meets concepts.
That, to us, is the essence of this devstory with Kostas Plakidas from fiskaly GmbH: choose environments that make you grow, seek problems that force you to look closer, and practice the mix of clarity and patience it takes to build systems that work today and remain shapeable tomorrow.
Keep options on the table—and choose with a long-term view. That’s architecture—and that’s the craft.
