My Career Midpoint, Part I

Prologue

In September 2026, I completed 15 years of a career in Information Technology — my Crystal Anniversary. That was enough time to accumulate stories and experiences spanning the job market and academic life. I decided to revisit these memories and write down lessons and curious stories, protecting the people involved as much as possible.

I could open with a preface about the period before my first formal job — the Technical IT Course and my first experiences with computers — but that chapter is for the future.

This story will have three main parts, milestones I consider important, spanning several years each, with a filler period between them: smaller stories, but no less interesting to recall.

As it couldn't be any other way, we'll start with the call to adventure.

Interns, wind pastries, and cemeteries

In June 2011, having been accepted into the University for All Program (PROUNI) with a guaranteed scholarship in São Paulo to study Information Systems, I made my first major decision: leaving my parents' house in the countryside to live in the capital, at 17 years old. I was already in my first semester of Systems Analysis and Development in my hometown, but nothing compared to the change in routine, scale, and challenges that came in the first months of this new life.

Studying alone wasn't enough. Every day I faced more than 100 km of round-trip travel, from Tatuapé, in the East Zone of São Paulo, to Cotia, in the São Paulo Metropolitan Region (RMSP). In those first months, I was taken in by my aunt on my mother's side, Cida, to whom I owe immense gratitude. She certainly worked as hard as I did and, despite being strict, is an extremely protective person.

This commuting challenge, on top of the routine at home, forced me to go after a job: make use of the daily trip between home and college to earn some income, gain my own independence, and save on commuting hours.

Searching on the sorely missed APInfo site, I sent out résumés for internship openings right in my first month of college. The first interview, luckily, landed me my first paid job, in September 2011: a small software consultancy, but with a big Enterprise Resource Planning (ERP) contract — a business management system — for an importer and retailer of clothing, footwear, and accessories.

As an intern, I earned a salary slightly above minimum wage at the time (R$545.00) and a stipend, a kind of cash meal allowance (VR). For a 17-year-old who previously had nothing, it was a big win.

That said, my productivity and focus — especially in calculus classes and during my ramp-up at the company, where I needed to work much harder to absorb the knowledge — were affected by the long commutes: for a few months, I left home at 5:30am to get to work, in the South Zone, by 10am, where I stayed until 5pm. Before college, I had a mandatory stop at a pastry stand in front of a church: a friendly pastel with some vague memory of a filling, for about R$4.00, always backed up by guava-flavored starch snacks in my backpack. Then I headed to college, in the East Zone. On the way back, the connection to Line 4 was already closed, so I'd catch the bus in front of Cemitério da Consolação and walk the entire length of Cardeal Arcoverde on foot, past sketchy bars and disreputable establishments, all the way to Largo da Batata, where I'd board one of the last two intercity buses, at 11:45pm or 12:10am. I'd get home, lie down, and a few hours later, start all over again.

Bigger than the paycheck, though, was the learning in that consultancy environment, where every developer did a bit of everything: building features, finding and fixing bugs, touching databases and infrastructure, working alongside people around the same age with plenty of willingness to put out fires. The business complexity spanned every area of a mid-sized company: inventory, logistics, tax, price tables, sales, Points of Sale (POS), and accounting.

Windev, French Rapid Application Development

The technology we used at the time, Windev, already felt a bit dated: a Rapid Application Development (RAD) environment, in which we built the ERP and the Point of Sale (PoS) applications. The tool abstracted away the more popular frameworks of the time, Java and the .NET Framework, with a proprietary framework: its own IDE, its own language, and its own database, though it came with connectors for other providers. In our case, we used Microsoft SQL Server as the Database Management System (DBMS).

Windev is an IDE built by a French company, PCSoft, with an integrated environment for developing desktop, web, and mobile applications: a proprietary language, WLanguage, its own database, HyperfileSQL (HFSQL), and interoperability with other languages and databases via APIs and drivers.

Some of its quirks come from the IDE's own design choices, which are quite an acquired taste, and from its proprietary language, a product of its era: a fourth-generation language (4GL). The idea was to speed up development by automatically generating artifacts once a database was hooked up to the project: the metadata became an abstract model called Analysis, similar to the .NET Framework's Entity Data Model, and from it, reports and screens could be generated with just a few clicks — something like SAP's Crystal Reports, or Oracle's ADF for rich interfaces.

In practice, this meant I didn't need to deeply understand databases to ship a working screen, which, looking back, was both good and bad at the same time.

The language also offered automatic data fetching: you just iterated over collections with bindings to the data model, and the metamodel took care of translating everything into database queries, whether HFSQL or another compatible engine, via OLE DB/ODBC connectors.

A simple example: searching for a customer by name, followed by iterating over the resulting collection, without writing a single line of SQL.

// Look up the first customer named "João"
HReadSeek(Customers, Name, "João")

IF NOT HFound(Customers) THEN
    Info("Customer not found")
    RETURN
END

// Iterate over all matching records
FOR EACH Customers
    sName = Customers.Name
    sEmail = Customers.Email
    nID = Customers.CustomerID
    Info(nID + " - " + sName + " (" + sEmail + ")")
END

Naturally, this created performance problems and hidden database behavior, since this kind of abstraction favors best-effort even at the cost of poor index usage and unoptimized queries. The result was chaotic situations in scaling scenarios, or wherever there were performance constraints, like in user-facing applications at the sales terminals. In those cases, we often fell back on Stored Procedures written in Transact-SQL to run the more expensive operations, like calculating cash flows, reprocessing inventory or price tables, and generating salesperson reports.

During this period, the software we delivered had a fairly artisanal character: specs and bug reports gathered in hallway conversations, over the phone, or in endless email threads. This forced us to build and maintain our own in-house service desk to collect issues and problem reports. Having always had a creative streak, I took on supporting this system to keep evolving it, building features, reports, and dashboards, and improving our day-to-day work.

Although Git had existed since 2005, my experience with source code management was still quite rudimentary: shared network folders with no versioning, and later a centralized version control system (CVS, Concurrent Versions System) from Windev's own vendor, which more than once corrupted our file history and forced us to fall back on physical backups. Deployments followed the same artisanal logic: zipped builds, transferred over FTP, with access configuration in plain-text .ini files. That was our reality for years.

Old-school PHP and other projects

Besides the ERP and its PoS system, the consultancy also worked on smaller projects, like e-commerce sites and hotel management systems. Those had more flexibility around technology choices, and we even used PHP and MySQL on the LAMP stack (Linux-Apache-MySQL-PHP), already on its last legs in the market, which kept moving toward the Node.js and nginx stack, even though we stuck with LAMP.

At the time, knowledge of frameworks in the PHP world was entirely experimental, at least for me. I remember studying CodeIgniter from Ademir Gabardo's book and using it for my capstone project, where I also got a taste of maker culture, using Arduino and a Raspberry Pi to prototype a smart water meter — a project that genuinely earned the highest possible grade. Professionally, though, the PHP I used was straight out of the 2000s: .php files with script blocks mixed into HTML, sharing the stage with iconic plugins of the era, like jQuery, for DOM manipulation, client-side validation, and animations, plus morris.js and chart.js for stylized charts. Bootstrap was still on its early versions, making its way into my projects bit by bit.

Studying on my own: the .NET world

A few months later, I was made a permanent Junior Programmer Analyst and, with a bigger paycheck, moved into a studio apartment near a subway station in the West Zone. My quality of life improved instantly: I finally slept full nights.

Just working with Windev and old-school PHP wasn't satisfying. In conversations with my great friend Mark — to me, a programming legend (especially, but not only, in Java) — always tuned into engineering best practices, who taught me software architecture before I even knew the term, I realized that sticking only to day-to-day tasks was pulling me away from where the market benchmark actually was. So I started studying .NET on my own, getting into C# and ASP.NET MVC through the hefty Step-by-Step series volumes by the late John Sharp, and through books from the also sorely missed Casa do Código publisher, like Maurício Aniche's fantastic TDD (Test-Driven Development) book, along with a few Windows Phone books, since I was an early adopter and enthusiast of the Nokia Lumia line 💀. It was still early, but that restlessness to study beyond my day-to-day routine would become the foundation of the repertoire I'd go on to build.

Time to move on

Before I knew it, three years had passed and I was now a Mid-Level Programmer Analyst. There had been many new ERP version deployments, cash-flow optimizations across brand groups, new store openings, features built and eventually rebuilt for various registration flows, integrations with thermal printers, and even setting up event booths at Anhembi. I had made great friends along this journey and was already about to finish my degree, in my final semester.

That's when the urge to make a change came: to step out of my comfort zone and take another risk in search of new challenges. Without much ceremony, I started testing the market again and, in May 2015, received an offer that, at the time, felt like a promise of fresh air. So it was time to say goodbye, at that company, to the friends who had taken me in and taught me so much in that early phase of the journey (years later, I'd return for a new, long-lasting project).

From there I moved on to a new software consultancy, but this time on a completely different project, now at the Forensic and Scientific Police department. Still finishing up college, in that same first half of 2015, that's where I got my first taste of a double workday — but that's a story for the next part.

I dedicate the end of this part to everyone who, at that time, took part in my journey: to Mark, to Vê, to the brothers Diego and Thiago, to Marcão, to Luiz XV, to Adrian 2, to Abel, to Dengo, and to so many others.