Skip to content
Kamil BinkoKB.
← Back to experience

3 years, immediately after university (Jul 2017 – Jul 2020)

Aviolinx

Junior developer → independent rule-engine contributor

  • .NET
  • Proprietary rule engine
  • Payroll & operations calculations

Software for airline operational management built around a proprietary rule engine used to evaluate aviation operations and personnel/payroll calculations.

Team

  • Small team: two senior developers and three junior developers
  • Marcin — technical lead
  • Adam — worked largely independently from the rest of the team
  • I joined as one of three junior developers

Challenge

Aviolinx operated in a highly specialized domain where software had to represent complex aviation regulations and operational rules.

My work was not simply implementing conventional business features — I spent much of my time working with the rule engine underpinning the system, modifying it and adding capabilities as the product evolved. The engineering challenge was understanding complex domain rules well enough to express them correctly in software.

Coming directly from university, I had to become productive in a domain with a substantial amount of specialized knowledge.

Solution

I approached the work directly: understand the problem, take ownership of the assignment, and deliver it.

Early on, I was given responsibility for implementing a substantial payroll feature largely independently, using the existing calculation infrastructure to calculate personnel payroll and expose it through the application's workflows. As a junior developer, I was trusted with a substantial piece of functionality and completed it without requiring extensive supervision.

Over the following three years, I worked extensively on the underlying rule engine, extending and modifying it as new requirements emerged — practical experience with software where correctness depends on accurately representing complicated real-world rules rather than straightforward application logic.

This is also where I began developing an approach to technical leadership that has stayed with me since: lead from the front and by example.

Result

I progressed from a newly graduated junior developer to a highly independent contributor working directly on the core rule engine, which established several foundations for how I approach engineering today: becoming productive in unfamiliar and complex domains, translating real-world rules into executable software, taking ownership of work, and leading through technical competence rather than title.

It was also an early lesson that technical leadership and organizational leadership aren't necessarily the same thing — I was considered for a team-lead transition after roughly a year, but the company promoted someone else without properly communicating that decision to me. That experience shaped my understanding of the difference between being capable of taking technical responsibility and being formally given organizational authority.