Inside ProSaldo.net Engineering: Scrum focus, a Microsoft .NET stack, and a feedback-first culture — insights from “Nihad Abou-Zid, Lead Software Engineer bei ProSaldo.net”

What stood out in the session

In “Nihad Abou-Zid, Lead Software Engineer bei ProSaldo.net,” Nihad Abou-Zid offered a concise, practice-oriented look at how ProSaldo.net structures its engineering team, runs recruiting, and makes technology decisions. At the core: a compact Scrum team, a Microsoft-leaning stack centered on .NET and C#, a deliberate pairing of manual testing with engineering, and a hiring approach that weighs technical depth and team fit equally. The team also looks ahead—upgrading .NET and evaluating SQL versus NoSQL to gain flexibility.

From the DevJobs.at editorial vantage point, here is how these points translate into day-to-day work, hiring expectations, and why this environment is compelling for engineers.

The team: five full-time developers, one freelancer, a Product Owner, and a manual tester

Nihad outlines a lean setup:

• Five full-time developers
• One freelancer
• A Product Owner who manages and hands over requirements
• A manual tester with deep product knowledge

This arrangement signals clear ownership and short feedback loops. In smaller engineering teams, decisions are visible, context is shared, and individuals can take meaningful responsibility. The Product Owner’s role ensures that requirements are channelled and translated into workable increments. An experienced manual tester points to a pragmatic quality strategy: the team doesn’t rely on automation alone—critical flows and product-centric scenarios are deliberately tested by a human expert.

Why a manual tester matters here

Many teams are all-in on automation. ProSaldo.net uses a complementary approach. As Nihad notes, their tester “really tests manually” and “knows the subject matter very well.” The advantages are clear:

• Domain depth: manual tests reflect real usage and nuanced user journeys that are hard to capture in automated suites.
• Early feedback: for UI nuances or interaction changes, human checks provide fast, product-relevant signals.
• Safety net for modernization: when upgrading .NET or evolving frontend components, manual quality assurance can catch regressions that are tricky to model purely in code.

Scrum in practice: familiar roles, disciplined execution

“Is grundsätzlich ein Scrum-Team,” says Nihad—short, but telling. With a dedicated Product Owner, a focused dev team, and a tester embedded in the cycle, the familiar Scrum scaffolding is present. In practice that means sprints, prioritized backlogs, reviews, and retrospectives serve as the operating system for how requirements flow into shippable increments.

For engineers, this typically translates to:

• Visibility into priorities via a maintained backlog
• Iterative delivery with continuous inspection and adaptation
• Early testing feedback that informs design and implementation
• A cadence for improvement (retrospectives), which dovetails with the feedback culture Nihad emphasizes

Recruiting that blends technical depth and team fit

The recruiting flow, as described by Nihad, is straightforward and collaborative:

1. HR kicks off the selection process and handles the initial filtering—“in coordination with us on the requirements.”
2. HR runs the first interview with promising candidates.
3. The CVs of those who pass are shared with Nihad and the Product Owner.
4. Engineering provides feedback, and joint follow-up interviews are scheduled together with HR.
5. These conversations cover technical aspects and personality—ensuring the person fits the team and the collaboration works.

The take-away: HR and Engineering operate as a single lane. Profiles must work on paper and in the dynamics of a real team. Candidates can expect both technical depth and substantial discussion about collaboration.

What matters in interviews

Nihad is explicit about the traits they value:

• Motivation to develop oneself—professionally and personally
• The ability to speak openly about criticism—both giving and receiving
• Willingness to adapt how work is done, together with the team

This is not icing on the cake; it’s central to how they operate. Modernization (e.g., upgrading .NET) and technology evaluation (e.g., considering NoSQL) depend on people who can learn, iterate, and collaborate candidly.

The stack: Microsoft .NET and C#, Microsoft SQL, Vue.js (2 and 3), and TypeScript for Vue 3

ProSaldo.net’s stack is “quite Microsoft-heavy,” as Nihad puts it:

• Backend: .NET Framework and C#
• Database: Microsoft SQL
• Frontend: JavaScript with Vue.js 2 and 3; TypeScript is used with Vue 3

This gives engineers a clear center of gravity and a useful breadth: a stable Microsoft backend world paired with a modern, reactive frontend framework. The coexistence of Vue 2 and Vue 3 is common in real-world systems and creates valuable learning opportunities:

• Understanding legacy and modern patterns side by side
• Gaining migration and typing experience (TypeScript) in Vue 3
• Being intentional at the seam between frontend and backend—aligning data shapes, validation, and error handling between C# domain models and typed frontends

Why TypeScript in Vue 3 is a strong signal

“We use TypeScript with version 3,” Nihad notes. In practice this means:

• Clearer, more maintainable code through explicit types
• Earlier error detection in the development environment
• Stronger contracts between frontend and backend models

Together with C# on the backend, a typed frontend aligns well with a consistent domain model—improving stability and developer experience.

Where it’s going: modernizing .NET and weighing SQL versus NoSQL

Two forward-looking signals from Nihad stand out:

• “Our .NET version is a bit older … we want to move to a newer version because it simply has more features and is better to work with.”
• “For the database, we need to consider whether NoSQL might fit better because it’s simply more flexible than classic SQL.”

Both statements show purposeful evolution. A .NET upgrade typically brings modern language features, performance and security improvements, and a current development experience—exactly the “better to work with” benefits Nihad points to. Engineers joining the effort will shape the plan, testing strategy, migration path, and production hardening.

The database question is equally engaging. Microsoft SQL is the current foundation. The team recognizes the potential flexibility of NoSQL and is evaluating fit. That evaluation demands technical judgment across data modeling, consistency needs, access patterns, and scale. For engineers, this is a hands-on learning and decision-making opportunity: technology choices are reasoned out and made together.

Collaboration with quality at the center

A notable aspect of Nihad’s account is how seriously quality assurance is treated. The dedicated manual tester “knows the domain well” and “really tests manually.” That signals a culture where real product usage has weight. In modernization phases and in environments where Vue 2 and 3 coexist, this matters. Manual tests frequently surface edge cases and UX aspects that are hard to encode in automation alone.

For the team, that means:

• Continuous feedback on regression risk
• Better safety during refactoring and version updates
• A shared language among Product Owner, developers, and tester—amplified by Scrum ceremonies like reviews and retrospectives

Expectations for new colleagues: curiosity, candor, and team play

Beyond hard skills, Nihad underscores:

• “Motivation to develop oneself”—personally and professionally
• Openness around criticism—both directions
• Readiness to adjust collaboration patterns together

This is an invitation to builders who care about craft and team outcomes. If you enjoy evolving existing systems while pushing modernization—raising .NET versions, embracing typed frontends, and weighing data store options—this environment aligns well with your interests.

Why ProSaldo.net is attractive for engineers

From DevJobs.at’s perspective, several concrete benefits are clear:

• A focused, compact team: high impact, clear lines of responsibility, direct communication.
• A clear stack: .NET/C#, Microsoft SQL, Vue.js (2 and 3) with TypeScript—balancing stability with modernization.
• Real agility: Scrum with explicit product ownership and a testing role that anchors quality in real product usage.
• A modernization agenda: upgrading to a newer .NET version and a thoughtful evaluation of NoSQL—meaningful engineering challenges instead of pure maintenance.
• A culture of openness: feedback, learning, and team fit are prioritized—creating a setting where growth and quality improve together.

Smart questions to bring to your interview

If you’re exploring a role at ProSaldo.net, these themes connect directly to Nihad’s points and show practical engagement:

• .NET upgrading experience: strategies for handling breaking changes and designing test coverage.
• Vue migration: moving from Vue 2 to Vue 3, adopting TypeScript, and understanding common pitfalls.
• Database decision criteria: evaluating SQL versus NoSQL across flexibility, development effort, and operations.
• Working with manual testers: combining exploratory testing with automation to cover critical flows end-to-end.
• Culture and feedback: examples where honest critique improved the outcome—and how you approach such moments.

These questions demonstrate that you understand the team’s reality and want to contribute to the decisions that matter.

What the hiring approach says about the culture

A joint HR–Engineering selection process, the balance of technical and personal evaluation, and a clear emphasis on learning motivation all point to a pragmatic, collaboration-first culture. This aligns with the team structure Nihad described: small, clear roles and a realistic, product-grounded view of quality.

Day-to-day engineering signals between the lines

Even from a concise description, we can infer helpful markers for day-to-day work:

• Prioritized execution: the Product Owner filters and sequences requirements so developers stay focused.
• Continuous validation: the manual tester is close to the product; changes are reviewed not just technically, but through real usage.
• Iterative progress: Scrum keeps feedback flowing—essential for modernization efforts.
• Collective decisions: upgrades and data-store choices involve the team, building shared ownership.

The road ahead: modernization as a team sport

Modernization is a journey, not a switch. Nihad’s notes on the .NET version and database options mark deliberate waypoints. For the team, this implies:

• Planning which components move when
• Building the safety net (manual and automated checks) that matches the risk profile
• Coordinating Product Owner, developers, and tester so change lands smoothly

If you thrive on this kind of collaborative evolution, ProSaldo.net offers a meaningful stage.

Closing takeaways: clear structure, modern ambition

“Nihad Abou-Zid, Lead Software Engineer bei ProSaldo.net” sketches a team that works with focus, treats quality as a first-class concern, and looks forward with intent. The combination of a Microsoft-centered backend, a modern frontend with Vue and TypeScript, disciplined Scrum, and a feedback-first culture makes ProSaldo.net appealing to engineers who want responsibility and tangible impact. If you bring curiosity, candor, and team spirit, you’ll find a setting where technical excellence and collaboration reinforce each other—and where modernization is not a slogan but a shared practice.