That’s the story of how I accidentally sparked the Python fire in Brazil.

I joined back in 2008 to work on the new content management system.

The CMS architecture was quite advanced for its time, resembling very much modern CQRS. We had a message event stream from the CMS editor and several pub/sub consumer workers for each media content.

Things like Image cropping and resize were an Async operation. Indexing a piece of published news and warming a cache entry was another.

The backend was pretty much settling on Java with jetty serving JSON via light HTTP servlets and workers.

ActiveMQ and ApacheCamel were used as the core of the event streaming architecture. Solr was used for full-text indexing and search. Classic Java stack for everything else.

Dev tooling and experience was the weak point of this design, and mostly the reason it sank. Remember, back in 2009, the closest thing to containers was chrooting.

The delivery front end at the time was implemented in Ruby on Rails using an internal thing very similar to what active resource come to be

Each web worker would fetch content back either from the cache layer or each content server in case of an eviction.

Varnish was deployed as the HTTP cache layer between our stack and the world.

The rails version was so lightweight that we could have replaced it with a custom rack middleware rendering templates with erb.

We struggled to get rails to an acceptable throughput and latency during initial performance testing as we exhaustively benchmark the stack.

Around the same time, Twitter was having severe issues in production with rails. They had some significant downtimes that started the meme “rails doesn’t scale” and sparkled many blogposts about their problems.

These articles started to circulate internally and concerns about the possibility of hosting rails apps in prod were increasing.

Back at the time, news portals were a thing, and served content to around 50 million unique users monthly. The concern was real.

After all the internal push back, we had a sprint to estimate the effort to convert the frontend to Java and use the old suspects.

I just had a traumatic burnout experience writing web apps with Java and GWT; I decided to go rogue and find alternatives to avoid reviving the pain.

I was having a hard time finding a flat, and I was living in a hostel without Wi-Fi, so I spent most of my evenings and weekends at work to enjoy the AC, privacy, and some internet.

During this period, I implemented three spike replacements. The frameworks I settled on after a few conversations Zend(PHP), Plone(python), and Django :)

If I’m not mistaken, I never finished the Plone version because it was impossible to turn off the backend and make it work.

The Zend version worked but was in PHP. And I’m not capable of writing beautiful PHP, and I honestly worked against it.

The Django version was right on the spot. I quickly converted all erb templates that we had to Django templates and reimplemented our HTTP client that supported rendering content if nested content was missing in the JSON response.

Python dictionaries turned working and unmarshalling JSON into a natural operation.

We run the same comparative performance testing over the Django version, and with a very similar deployment, we got a very stable and fast render.

I got very excited about Django, when to the US to attend the first Django con at Google headquarters.

I met amazing people doing all sorts of crazy projects with rails. I remember meeting and talking with lea culver, Simon Wilson, Jacob Kaplan-Moss, and several other core members of the team. Guido also attended the event and was very accessible.

Returning from the conference, I brought back some ideas to the team. Other teams had already started to pick up with python and Django and started moving and creating new things.

Frontend was never my strong, and having more exciting problems behind the curtains, I pushed for us to hire some python people so I could go back to my dungeon.

Our first hire was Andrews Medina. The guy had a love for the language and turned things around for good. The platform was soon rewritten entirely in Django, and I left the team to work on a web semantics project.

The company continued pushing python, hiring more engineers, sponsoring events and developing even better projects.

The word spread soon, and the almighty was using python and serving as an example for other companies to follow.

And that’s the story of how at least for a group of close friends, I accidentally put python at