DEV Community: Frederico Maia

Big Changes at Meteor Software: Our Next Chapter

Frederico Maia — Fri, 16 May 2025 17:02:54 +0000

As the CEO of Meteor Software for the past 3 years, I wanted to share some major exciting things about where we're heading. When I first joined the company, I had a clear vision to modernize Meteor and transform Galaxy into something bigger.

Today, I'm excited to tell you that these changes are finally happening.

A New Era, A New Identity

First things first! We're introducing fresh new brands for both Meteor and Galaxy. This isn't just a cosmetic facelift. It shows that we are changing our direction in a significant way.

We've been using the original Meteor logo for more than 13 years, and it has become quite recognizable within the JavaScript community. The decision to change it wasn't made hastily, but we felt it was essential to reflect our ongoing evolution.

Our new Meteor brand represents our commitment to modern JavaScript. It features a cleaner, more contemporary design that represents our future direction rather than just our heritage. The redesigned Meteor website is now ready and includes a really cool interactive demo that showcases what Meteor can do. We're excited for you to check it out and experience Meteor's capabilities firsthand.

Meanwhile, Galaxy's new independent brand shows it's growing beyond its Meteor-only roots into a robust, multi-stack cloud platform.

Meteor 3: Embracing the Node.js Ecosystem

After countless long nights and coffee-fueled coding sessions, we released Meteor 3.0 in July 2024 (now we're at version 3.2). This release wasn't just another version bump. It shows where we want to go in the future. We changed from using Fibers to using async/await, which is what most developers use now. We also support the newest version of Node.js. These changes help Meteor work better with other Node.js tools.

This is important because instead of maintaining our own solutions for everything, we're now able to use the best tools the JavaScript ecosystem has to offer. Why reinvent the wheel when there are already amazing solutions out there? Since I started working at Meteor Software, I wanted Meteor to work well with other Node.js tools instead of being separate and alone.

What's Coming in 2025

Looking ahead, our 2025 roadmap shows exactly where we're heading. We're embracing integration with powerful, proven tools instead of making everything ourselves.

Bundle Optimization: Our Current Priority

We're working to make Meteor apps smaller and faster:

Working with modern bundlers: We're making it easy to use RSPack, ESBuild, and Rollup so your apps will load faster and use less memory
Faster builds: With our new tools (added in version 3.2), we're making builds take less time
Better development experience: Making changes to your code will show up more quickly while you're developing

Other Important Improvements

We are also going to work on:

Modernized RPC Methods and Publications: Adding self-documenting code, better validation, and more intuitive interfaces while maintaining backward compatibility
MongoDB Change Streams: Using the official way to get real-time updates from MongoDB
Better TypeScript support: Making it easier to use TypeScript with Meteor and its packages
CapacitorJS for mobile apps: A better, newer way to build mobile apps than our old Cordova system
Faster releases: Making our own process quicker so you get updates sooner

All these changes will solve real problems that developers face every day.

We will write clear, helpful guides about all these new features so everyone can use them easily, whether you're new to Meteor or have used it for years.

Galaxy Expands Its Universe

I'm particularly excited to share what is perhaps our most significant announcement. Galaxy is undergoing a comprehensive transformation. Upon joining the company, I recognized Galaxy's potential to evolve beyond its role as a Meteor-only hosting platform. Today, I'm pleased to announce that we're realizing this ambitious vision.

Galaxy 2.0 integrates our previous dashboard and backend systems into a cohesive, intuitive platform that significantly enhances the user experience. The truly revolutionary aspect, however, is Galaxy's expanded support capabilities. The platform now supports Node.js and Python applications, including frameworks such as Express, Nest, Adonis, Flask, and Django. And we're developing support for Ruby on Rails, which will be available in the coming months.

Our promise is simple but powerful. We'll provide the most user-friendly cloud platform and the most responsive support team available. We believe cloud hosting shouldn't be complicated, and when you need help, you deserve proper answers from people who understand your challenges.

Complete Platform with Database Solutions

In 2024, we enhanced Galaxy by adding MongoDB hosting directly on the platform. This significantly simplified deployments for teams needing reliable, managed MongoDB solutions. We're continuing this evolution in 2025 by expanding our database offerings to include PostgreSQL, Redis, and FerretDB.

These additions transform Galaxy into a comprehensive platform for hosting applications and databases together, streamlining deployment and management considerably.

This isn't just an upgrade. It's a complete transformation. Galaxy now operates as an independent platform with its own dedicated website and distinct brand identity separate from Meteor. The new Galaxy brand reflects our commitment to serving a wider developer community while maintaining the reliability our users expect. We're making a substantial investment in this expansion for 2025.

Our Team Structure

I want to be transparent about our organization. These advancements are being delivered by dedicated, autonomous teams working diligently behind the scenes.

We operate with two specialized technical teams, each led by its own tech lead while sharing the same CTO. The teams maintain separate roadmaps and priorities, focusing exclusively on their respective products. The Galaxy team advances our cloud platform, while the Meteor team enhances and maintains our open-source framework. Our DevOps specialists, though formally part of the Galaxy team, provide support to both divisions when infrastructure requirements arise.

This organizational approach ensures consistent attention to both products, with Meteor and Galaxy each receiving the focused development they require.

Why These Changes Matter

I won't present you with buzzwords or empty promises. As developers ourselves, we understand what's truly important: reliable tools that enhance productivity and effectiveness. These changes address genuine requirements:

Meteor requires improvements on DX, scaling, and compatibility with modern JavaScript
Galaxy needed to support additional technologies because that's what teams actually use in the real world
Both products needed to communicate their evolution with new, modern brand identities

The refreshed branding for Meteor and Galaxy isn't merely cosmetic. These are deliberate declarations of our direction. They demonstrate our dedication to innovation and our readiness to meet current development demands. The real improvements are in the technology and its capabilities. We're committed to developing robust, practical solutions for real-world development challenges.

Try It Today

If you're a Meteor developer, I encourage you to upgrade to Meteor 3 today. You'll immediately feel the benefits of native async/await and modern Node.js features. Meteor 3.3, which is currently in beta, already brings faster builds. Check out Meteor 3 docs.

For those working with Node.js, Python, and their popular frameworks, consider exploring Galaxy. Visit our new Galaxy website to discover how we've simplified cloud deployment.

I'm really proud of what our teams have built, but we're just getting started. There's so much more coming down the pipeline, and we'll keep you updated as we roll out new features.

Let's build amazing things together.

Galaxy Meets Monti APM - Build Fast and Error-Free Meteor Apps

Frederico Maia — Thu, 16 May 2024 15:06:29 +0000

For developers immersed in MeteorJS, the story of Application Performance Monitoring (APM) tools reflects innovation, change, and growth led by the community.

A Quick Look Back

A key moment in this story was when Arunoda created Kadira, the first APM made just for Meteor. This was a big deal because it helped developers find and fix slow parts in their Meteor apps. Seeing its importance, when Kadira APM was shut down, MDG bought Kadira APM, renaming it Meteor APM and integrating it into Galaxy. They also made the Kadira APM code available to everyone. This move gave developers deep insights into their apps, covering everything from methods and publications to the complete lifecycle, significantly improving the Meteor ecosystem.

Launch Week - Day 4

We're excited to announce the transition from Meteor APM to Monti APM, aiming to provide our developers with even more powerful tools. This change comes as part of our commitment to continuously enhance the development experience within the MeteorJS ecosystem.

Why transitioning from Meteor APM to Monti APM?

Over the past few years, Meteor APM has seen a period of stability rather than rapid evolution in terms of new features. Meteor APM continues to serve as a crucial tool for developers in monitoring and diagnosing performance issues within their Meteor applications. We have focused on maintaining the reliability and functionality of Meteor APM, ensuring that it remains operational and continues to provide value to the community. This work is crucial, as it ensures that existing features remain useful and that the tool keeps pace with the latest Meteor framework updates.

However, in terms of introducing new features and capabilities, we couldn’t make significant advancements. While maintaining Meteor APM is vital for existing users to ensure stability and reliability, the dynamic and ever-evolving nature of software development demands continuous innovation to address new performance monitoring challenges and opportunities.

In contrast, Monti APM has taken a path of active development and feature expansion.

Enter Monti APM

Monti APM, picking up where Kadira APM left off, has continued to deliver that same level of insight and support but with added features and enhancements. Led by Micaiah (aka Zodern), Monti APM is dedicated to providing an APM solution that’s finely tuned for the needs of today’s Meteor applications.

Monti APM has emerged as a robust alternative by adding an array of new features and improvements tailored to modern development practices. Some of the notable features include:

CPU Profiling: Dive into your app’s CPU usage to find and fix heavy-load functions, making your app run smoother and faster.
Error Insights: Get a clearer picture of errors, spotting trends and issues that need your attention to boost your app’s quality.
Custom Alerts: Stay on top of potential problems with alerts tailored to specific metrics. Use Slack notifications and Webhooks for real-time updates.
System Dashboard: A comprehensive view of your Node.js servers, offering an inside look at what’s happening under the hood.
API: Access collected data through a GraphQL API for custom dashboards, integrations, or unique data exploration.

Learn more about how to use these features by visiting Monti APM’s documentation.

Transitioning to Monti APM

Our team is working to promote a smooth switch from Meteor APM to Monti APM. This change shows our dedication to giving Meteor developers the best tools out there.

How do you get access?

When the feature is ready, hopefully, by the end of this month, we'll let everyone know through email and social media. Just like now, if you have the Professional plan, you can use Meteor APM; you'll also be able to use Monti APM. The setup will be easy, and you can manage your app with Monti APM by clicking a link in Galaxy 2.0.

Moving to Monti APM isn't just an upgrade; it's a step forward for all of us in the Meteor community who aim for innovation and excellence. Stay tuned for updates as we roll out Monti APM. Together, we can make our Meteor applications stronger, faster, and error-free.

Meteor.js with Vite, Solid, and Tailwind CSS

Frederico Maia — Wed, 10 May 2023 14:55:04 +0000

In the world of web development, choosing the right tools can make a significant difference in the efficiency and quality of your projects. In this blog post, we will learn how to create a new project using four powerful tools: Meteor.js, Vite, Solid, and Tailwind CSS. This combination can elevate our development experience.

Meteor.js is a full-stack platform that simplifies the development of web applications by providing a unified approach to building both the front-end and back-end. With real-time data updates, Meteor.js speeds up the development process and ensures you can create powerful applications.

Vite is a next-generation build tool that significantly enhances development. Integrating Vite with Meteor.js and Solid can further boost development efficiency and application performance.

Solid is a unique JavaScript library designed for creating user interfaces more efficiently. Rather than using a Virtual DOM like many other frameworks, Solid compiles its templates to real DOM nodes and updates them with precise reactions.

Tailwind CSS is a utility-first CSS framework that enables developers to quickly design responsive, modern websites and applications without writing repetitive CSS code. By providing a set of predefined utility classes, Tailwind CSS streamlines the styling process, allowing you to focus on the overall layout and design.

When combined, Meteor.js, Vite, Solid, and Tailwind CSS create a powerful synergy that can dramatically enhance your web development experience.

Before diving into the tutorial, you should know that it's possible to quickly generate a Meteor.js + Vite + Solid app using the following command:

meteor create meteor-solid-app --solid

However, in this tutorial, we'll guide you through each step to provide a deeper understanding of the process.

Create your Meteor.js project

Start by creating a new Meteor project using the --minimal flag. If you don't have Meteor.js installed yet, follow our instructions here. This option generates a project with the minimum required Meteor packages. Upon creation, a subdirectory with the same name is also created. Please navigate to the project folder and run it to ensure the proper setup.

meteor create meteor-solid-app --minimal
cd meteor-solid-app
meteor npm start

You should see a simple app as below:

To use the most recent dependencies, review your package.json file and update your dependencies accordingly:

...
"dependencies": {
  "@babel/runtime": "^7.21.5",
  "meteor-node-stubs": "^1.2.5"
},
...

Run meteor npm i to install the newly added dependencies above.

Install Vite and Solid

Execute the commands below to install Vite and Solid:

meteor add vite:bundler
meteor npm i -D vite vite-plugin-solid
meteor npm i solid-js

Create a Vite configuration file (vite.config.js) in your project root and import the Solid plugin. Since we are not using a standard Vite index.html file, specify an entry point to a new file that will be created inside the ui folder called main.jsx:

import { defineConfig } from 'vite'
import solidPlugin from 'vite-plugin-solid';

export default defineConfig({
  plugins: [
    solidPlugin(),
  ],
  meteor: {
    clientEntry: 'ui/main.jsx',
  },
})

Write your code from this entry point, and let Vite handle it! ⚡️

Create the entry point

Create the ui folder and the file ui/main.jsx with the following content:

import { render } from 'solid-js/web';
import { Meteor } from "meteor/meteor";
import { App } from "./App";

Meteor.startup(() => {
  render(() => <App/>, document.getElementById('root'));
});

We will create the App component later. Now, replace the contents of client/main.html with:

<head>
    <title>Meteor.js with Vite, Solid, and Tailwind CSS</title>
</head>
<body>
 <noscript>You need to enable JavaScript to run this app.</noscript>
 <div id="root"></div>
</body>

Delete the content from client/main.js and add a comment as follows:

    // The main entry point for the app can be found in ui/main.jsx.

Install and Configure Tailwind CSS

Install tailwindcss and its peer dependencies via npm, then run the init command to generate both tailwind.config.js and postcss.config.js.

meteor npm i -D tailwindcss postcss autoprefixer
meteor npx tailwindcss init -p

In your tailwind.config.js file, add the paths to all of your template files:

/** @type {import('tailwindcss').Config} */
module.exports = {
  content: ["./ui/**/*.{js,jsx,ts,tsx}"],
  theme: {
    extend: {},
  },
  plugins: [],
}

Include the Tailwind directives in your client/main.css file:

@tailwind base;
@tailwind components;
@tailwind utilities;

Create Your First Solid Component

Create the file ui/App.jsx with the following content:

export const App = () => (
  <div className="p-4">
    <h1 className="text-3xl font-bold text-indigo-800">
      Meteor + Solid + Tailwind
    </h1>
  </div>
);

From the app folder, run the meteor npm start command to launch your app. You should see a simple heading with an indigo color.

Using Signals

Signals are the foundation of reactivity in Solid. They contain values that change over time; when you update a signal's value, anything that uses it is automatically updated.

To create a signal, import createSignal from solid-js and call it from your App component. Additionally, create an increment function that will be called when a user clicks a button.

import { createSignal } from "solid-js";

export const App = () => {
  const [counter, setCounter] = createSignal(0);
  const increment = () => {
    setCounter(counter() + 1);
  };
 ...
}

Enhance your component to display the counter on the screen and include a button to increment the counter. Your complete App component should resemble the following:

import { createSignal } from "solid-js";

export const App = () => {
  const [counter, setCounter] = createSignal(0);

  const increment = () => {
    setCounter(counter() + 1);
  };

  return (
   <div className="p-4">
    <header>
      <h1 className="text-3xl font-bold text-indigo-800">
        Meteor + Solid + Tailwind
      </h1>
    </header>
    <section>
      <p className="py-4 font-semibold">You've pressed the button {counter()} times.</p>
      <button
        onClick={increment}
        type="button"
        className="rounded bg-indigo-800 px-2 py-1 text-sm text-white"
      >
        Click Me
      </button>
    </section>
   </div>
  );
}

Great! From the app folder, run meteor npm start to launch your app.

Deploy Your App and Share with Friends

Create a Meteor Cloud account by using this URL, log in from your terminal, and execute the command below to deploy it for free:

meteor login
meteor deploy meteorsolidapp.meteorapp.com --free --mongo

You could also create a Git repository with your project and deploy it from there. Learn how to do it by reading our guide.

By using a meteorapp.com domain, there's no need to register one just for testing your app. The --free --mongo flags deploy an app using our free plan, including MongoDB.

Keep in mind that the subdomain meteorsolidapp.meteorapp.com is already in use, so you'll need to choose a different one for your app. Now, please share it with your dev friends!

Enjoy exploring the complete source code for this tutorial on this GitHub repository. If the code has changed since the time of this post, you can always refer to this specific release for the original version.

Conclusion

In this blog post, we walk you through creating a Meteor project with Solid, Vite, and Tailwind CSS. We cover setting up the appropriate configuration and making your first Solid app.

Let us know if you would like to see part 2 of this blog post, showing how to connect subscriptions and methods from Meteor to Solid. Remember that you can already see an example app by generating it from the command line using the --solid flag.

Feel free to share your feedback or ask questions in the comments below. Happy coding!

Instalando Tailwind CSS 2 em um projeto Meteor 2.6

Frederico Maia — Wed, 10 Nov 2021 00:05:06 +0000

English version.

Atualização: este tutorial é para o Meteor 2.6 e versões anteriores. Meteor agora tem suporte ao Tailwind 3, você pode seguir este post mais recente Meteor.js with React and Tailwind CSS 3.

Meteor é um framework JS super produtivo que nos permite implementar funcionalidades tanto no backend quanto no frontend. Tailwind é um framework CSS para construirmos websites e apps modernos. A combinação dos dois nos dá um excelente combo!

O Tailwind CSS tem algumas particularidades na hora de fazer o build e parse das nossas páginas, por isso precisamos de alguns passos para integrá-los.

Criando seu projeto

Inicie criando um novo projeto Meteor se você ainda não possui um criado, entre no diretório do projeto e o execute para garantir que está tudo certo.

meteor create my-project
cd my-project
meteor run

Por padrão, Meteor usa React e cria um subdiretório chamado my-project.

Instalando Tailwind via npm

meteor npm install tailwindcss@2.2.19 postcss@8.3.1 postcss-load-config@3.1.0 autoprefixer@10.4.0

É recomendado utilizar o comando meteor npm ao invés de somente npm para usar a versão do npm que já vem com o próprio Meteor.

Meteor ainda não é compatível com Tailwind 3.

Instalando um pacote Meteor para postcss

Instale juliancwirko:postcss e remova o minificador padrão do Meteor.

meteor remove standard-minifier-css
meteor add juliancwirko:postcss

Configure o postcss

Crie um arquivo chamado .postcssrc.js, adicione o tailwindcss e o autoprefixer à sua configuração do PostCSS.

// .postcssrc.js
module.exports = ctx => {
  // This flag is set when loading configuration by this package
  if (ctx.meteor) {
    const config = {
      plugins: {
        tailwindcss: {},
        autoprefixer: {},
      },
    };

    if (ctx.env === 'production') {
      // "autoprefixer" is reported to be slow,
      // so we use it only in production.
      config.plugins.autoprefixer = {
        overrideBrowserslist: ['defaults'],
      };
    }

    return config;
  } else {
    return {};
  }
};

Inclua o Tailwind em seu CSS

Adicione o Tailwind ao seu arquivo main.css.

// main.css
@tailwind base;
@tailwind components;
@tailwind utilities;

Configure o Tailwind

Crie um arquivo chamado tailwind.config.js com o conteúdo abaixo:

// tailwind.config.js
module.exports = {
  purge: [],
  darkMode: false, // or 'media' or 'class'
  theme: {
    extend: {},
  },
  variants: {},
  plugins: [],
}

Construindo seu CSS

Quanto estiver construindo seu app para produção, garanta que configurou a opção de purge para remover quaisquer classes de CSS não utilizadas para ter o menor tamanho de arquivo possível:

// tailwind.config.js
module.exports = {
  purge: ['./imports/ui/**/*.{js,jsx,ts,tsx}', './public/*.html'],
  darkMode: false, // or 'media' or 'class'
  theme: {
    extend: {},
  },
  variants: {},
  plugins: [],
}

Referências:
https://tailwindcss.com/docs/installation
https://github.com/meteor/examples/tree/main/tailwindcss

Installing Tailwind CSS 2 in a Meteor project

Frederico Maia — Thu, 04 Nov 2021 11:50:27 +0000

Versão em português.

Update: this tutorial is for Meteor 2.6 and lower versions. Meteor now supports Tailwind 3, you can follow a more recent blog post Meteor.js with React and Tailwind CSS 3.

Meteor is a super productive JS framework that allows us to implement functionalities in both the backend and the frontend sides. Tailwind is a CSS framework for building modern websites and apps. The combination of the two gives us an excellent combo!

Tailwind CSS has some peculiarities when it comes to building and parsing our pages, so we need some steps to integrate them.

Creating your project

Start by creating a new Meteor project if you don’t have one set up already, enter in the project folder and run it to make sure it is all correct.

meteor create my-project
cd my-project
meteor run

By default, it uses React and makes a subdirectory named my-project.

Install Tailwind via npm

meteor npm install tailwindcss@2.2.19 postcss@8.3.1 postcss-load-config@3.1.0 autoprefixer@10.4.0

It is recommended to use meteor npm command instead of only npm to use the npm version bundled with Meteor itself.

Install Meteor package for postcss

Install juliancwirko:postcss and remove the Meteor standard minifier.

meteor remove standard-minifier-css
meteor add juliancwirko:postcss

Configure postcss

Create a file named .postcssrc.js, add tailwindcss and autoprefixer to your PostCSS configuration.

// .postcssrc.js
module.exports = ctx => {
  // This flag is set when loading configuration by this package
  if (ctx.meteor) {
    const config = {
      plugins: {
        tailwindcss: {},
        autoprefixer: {},
      },
    };

    if (ctx.env === 'production') {
      // "autoprefixer" is reported to be slow,
      // so we use it only in production.
      config.plugins.autoprefixer = {
        overrideBrowserslist: ['defaults'],
      };
    }

    return config;
  } else {
    return {};
  }
};

Include Tailwind in your CSS

Add Tailwind to your main.css file.

// main.css
@tailwind base;
@tailwind components;
@tailwind utilities;

Configure Tailwind

Create a tailwind.config.js file with the content below:

// tailwind.config.js
module.exports = {
  purge: [],
  darkMode: false, // or 'media' or 'class'
  theme: {
    extend: {},
  },
  variants: {},
  plugins: [],
}

Building your CSS

When building for production, be sure to configure the purge option to remove any unused classes for the smallest file size:

// tailwind.config.js
module.exports = {
  purge: ['./imports/ui/**/*.{js,jsx,ts,tsx}', './public/*.html'],
  darkMode: false, // or 'media' or 'class'
  theme: {
    extend: {},
  },
  variants: {},
  plugins: [],
}

References:
https://tailwindcss.com/docs/installation
https://github.com/meteor/examples/tree/main/tailwindcss

Meus salários como Desenvolvedor no Brasil e como foi a evolução da minha carreira

Frederico Maia — Mon, 17 Feb 2020 13:32:16 +0000

Se você é desenvolvedor de software e usa o Twitter com certa frequência, deve ter visto a enorme discussão deste último final de semana sobre ser positivo ou negativo a divulgação de salários na rede.

Isso começou com programadores gringos e foi parar no Brasil, porém com toda a polêmica gerada muitas pessoas que haviam divulgado os salários, inclusive eu, resolveram apagar.

A intenção me parecia boa, ao menos a minha era boa, mas alguns pontos negativos levantados faziam sentido. Então, resolvi tentar tirar algo de bom dessa treta toda e compartilhar com vocês um pouco da minha trajetória. As pessoas que me acompanham no Instagram (@fredmaiaarantes) ou no Youtube (Goianos na Irlanda) sabem que hoje moro na Irlanda e sempre gero conteúdos pra ajudar e informar quem tem interesse de trabalhar por aqui. Porém vou compartilhar apenas meus salários de quando eu morava no Brasil.

A minha intenção aqui é mostrar que todos (ou quase todos) começam de baixo e tentar mostrar um pouco de como eu consegui ir evoluindo na minha carreira e ir aumentando meu salário com o tempo.

O início é difícil pra todo mundo. Para alguns, é muito mais difícil que pra outros. Eu sou muito privilegiado de, ao trancos e barrancos, ter tido condições de estudar em uma faculdade, ter comida em casa e não precisar trabalhar pra me sustentar, já que morava com meus pais que me proviam tudo isso. Apesar dos privilégios, espero contribuir com minhas experiências. E espero que mais pessoas compartilhem as suas.

Vamos às experiências profissionais, iniciando pelo início! Passei por muitas empresas, então vou tentar ser direto nas respostas seguindo uma linha do tempo como se estivesse falando do meu currículo.

Ao final do post, tentarei sumarizar algumas dicas e concluir o que mais contribuiu para o meu crescimento profissional, pensando em carreira e pensando em salário. O salário não será 100% certo, pois não lembro o valor exato de alguns. Vamos lá!

Minha trajetória profissional no Brasil

Maio/2008 - Outubro/2010: Estagiário (Goiânia)
Como soube da vaga e me candidatei?
Após participar de um evento gratuito da Microsoft chamado Student to Business, meu currículo foi parar no banco de dados da empresa e fui comunicado sobre o processo de seleção.

Quanto era o salário?
Comecei minha jornada ganhando R$200,00 + vale transporte para trabalhar por meio período. Ganhei alguns aumentos nesse período e após 2 anos passei a trabalhar full-time. Quando saí em 2010 ganhava por volta de R$800,00 por mês.
Aprendi muito por lá e mesmo tendo recebido ofertas com salários melhores, eu preferi continuar no estágio, pois tinha certeza que o meu aprendizado valeria muito a pena pra minha carreira.

Por qual motivo saí da empresa?
Decidi sair pois queria focar em desenvolvimento Java, nessa empresa eu trabalhava com projetos muito diversos. E enxergava que o foco em uma linguagem iria me fazer um profissional melhor e teria melhores oportunidades.

Novembro/2010 – Julho/2011: Desenvolvedor Java (Goiânia)
Como soube da vaga e me candidatei?
Um amigo meu era consultor Java e nos ajudou na empresa anterior. Ele me falou que precisavam de um desenvolvedor Pleno para um projeto deles e me perguntou se eu tinha interesse. De início eu falei que não, pois era estagiário e perguntei se tinha vaga de Júnior, ele me convenceu de que eu daria conta de encarar a vaga de pleno, me deu dicas pro processo seletivo e eu passei.

Quanto era o salário?
De R$800,00 na empresa anterior, passei a ganhar R$2.200,00. Foi um salto gigante pra mim, tanto na carreira quanto financeiramente. Era contratado como cooperado e não como CLT.

Por qual motivo saí da empresa?
Por não ser CLT eu já entrei nela pensando em ficar pouco tempo. Na minha cabeça e por pressão da família eu precisava de um emprego CLT. Então saí quando tive essa oportunidade.

Agosto/2011 – Agosto/2012: Desenvolvedor Java (Goiânia)
Como soube da vaga e me candidatei?
Um amigo que era instrutor de cursos na primeira empresa que fiz estágio, trabalhava nessa nova empresa. Eles tinham um sistema gigante que seria migrado de Delphi para Java. Esse amigo comentou com outro amigo em comum sobre a vaga, eu entrei em contato com ele pra saber mais, pedir umas dicas e me candidatei.

Quanto era o salário?
O salário era algo por volta de R$2.600,00 e depois tive algum aumento. O projeto era muito importante na empresa, fazíamos parte do departamento de inovação e tínhamos uma enorme resposabilidade no futuro da empresa.

Por qual motivo saí da empresa?
Nessa época eu passei a me interessar por outras linguagens, testes automatizados e TDD. Fiz um processo seletivo na Thoughtworks, me apaixonei pela cultura da empresa, fui aprovado no processo seletivo mas acabei recusando a proposta. Eu teria que mudar de cidade e não era o momento adequado na minha vida pessoal.
Pouco tempo depois uma startup entrou em contato comigo e tinha similaridades com o que eu queria trabalhar, linguagens diferentes e uma cultura ágil. Entrei nela mas meu tempo nessa startup foi bem curto então nem vou citar.

Novembro/2012 – Maio/2013: Desenvolvedor Scala (Goiânia)
Como soube da vaga e me candidatei?
As coisas não foram bem na startup que entrei anteriormente. Expectativa e realidade de ambas as partes não bateram. Mais uma vez, amigos do grupo de Java que eu participava me indicaram para essa nova vaga.

Quanto era o salário?
O salário era algo por volta de R$3.300,00. Meu objetivo de aprender linguagens novas estava sendo alcançado. Trabalhei principalmente com Scala e também com Groovy em projetos bem legais e inovadores.

Por qual motivo saí da empresa?
Pela primeira vez eu saí por causa de salário. Meu salário líquido era algo por volta de R$2.700,00 (não lembro exatamente). Recebi uma proposta muito boa, irrecusável na minha opinião e decidi aceitar.

Junho/2013 – Agosto/2014: Consultor Java (Goiânia)
Como soube da vaga e me candidatei?
Nesse período eu estava ministrando cursos de Java e comecei a dar aulas particulares para um aluno que após algum tempo me disse que era dono de uma empresa e estava estudando Java para entender melhor como funcionava pois precisaria em breve de um consultor para um projeto grande que estava pra fechar.

Quanto era o salário?
Nessa empresa também entrei com o modelo de cooperativa e meu salário líquido era de R$5.000,00. Quase o dobro do valor líquido anterior.

Por qual motivo saí da empresa?
Decidi me mudar de Goiânia nessa época, em busca de desafios novos e maiores na minha carreira. Analisei São Paulo, Rio de Janeiro e Porto Alegre e acabei conquistando uma oportunidade no Rio de Janeiro e decidi me mudar.

Agosto/2014 – Maio/2015: Desenvolvedor Java / Groovy (Rio de Janeiro)
Como soube da vaga e me candidatei?
Na minha busca por uma nova cidade e projetos maiores, entrei em contato com um amigo que morava no Rio e coincidência ou não, havia uma vaga aberta na empresa que ele trabalhava, enviei meu CV e já estava com viagem de férias planejada para o Rio, todas as datas bateram, fiz o processo seletivo e fui aprovado.

Quanto era o salário?
A contratação era CLT e o salário algo por volta de R$5.500,00. O valor líquido diminuiu bastante se comparado ao meu emprego anterior. Ainda saí da casa dos meus pais e passei a pagar aluguel e todas as minhas contas. Além de ir morar em uma cidade com custo de vida bem maior. Apesar de acabar ganhando menos, era o melhor pra minha carreira.

Por qual motivo saí da empresa?
Eu era terceirizado em uma empresa para um projeto do Governo e nessa época com o escândalo do mensalão e a crise iniciada no Rio, o projeto chegou ao fim antes do tempo previsto. Saí da empresa pouco antes do prazo final do projeto.

Abril/2016 – Setembro/2017: Líder de Time e Desenvolvedor Java / JavaScript (Remoto)
Como soube da vaga e me candidatei?
Mais uma vez, um amigo meu me indicou. Ele foi passar uns dias lá em casa no Rio e me falou da empresa atual. Trabalho remoto, algo que eu buscava há tempos. Nao tinha vaga aberta mas com a indicação dele a empresa resolveu me testar. Fiz todo o processo seletivo, fui aprovado e criaram uma vaga pra mim.

Quanto era o salário?
Se não me engano entrei ganhando R$7.500,00 e depois foi para R$8.000,00. Nessa época me mudei para Goiânia novamente, depois voltei para o Rio, depois vim para a Irlanda. Sinto sua falta trabalho remoto <3.

Por qual motivo saí da empresa?
Estava morando na Irlanda e ganhar em reais e gastar em euros não estava sendo fácil. Passei em um processo seletivo na Irlanda onde consegui o visto de trabalho e dei outro grande passo na minha carreira, iniciando meu primeiro trabalho internacional.

Como consegui aumentar meu salário?

Bem, você pode perceber claramente que em toda mudança de emprego, ao menos em quase todas, meu salário foi aumentando. É o que mais dizem por aí que pra conseguir um aumento significativo você tem que trocar de empresa. Nao é o que me motiva, nunca foi, claro que o salário é muito importante mas não é o mais priotário pra mim. Em apenas uma dessas mudanças o salário foi o que me fez trocar de emprego.

Minhas mudanças são sempre muito mais focadas no meu crescimento pessoal e profissional, avalio muito bem a cultura da empresa, projetos, ambiente, tecnologias e vejo se ambos (eu e a nova empresa) vão sair ganhando. Parte do que chamam de cultural fit.

Outro fator sempre muito presente e que colaborou muito com meu crescimento foi o networking. O famoso QI (quem indica). Muita gente acha que networking é ter muitas conexões no LinkedIn. Pra mim é ter conexões reais com pessoas que compartilham dos mesmos objetivos, que geram valor um pro outro e que se ajudam na jornada de aprendizagem e profissional.

Já ouvi dizer que com QI é muito fácil. É claro que facilita, com certeza ajuda. Mas uma indicação real, uma recomendação sólida, só é feita quando se conhece de perto a pessoa e há confiança no trabalho dela. Ninguém recomenda um amigo na empresa se esse amigo for alguém que não agrega valor e que não se esforça para dar o seu melhor no trabalho.

E como se faz networking? Posso dizer como foi pra mim. Participando de eventos da área, ministrando palestras em eventos, mais a frente sendo coordenador de grupos de tecnologia, indo atrás de patrocínios, locais para eventos e etc. Contribuindo com outras pessoas de forma genuína.

Tive blog por muitas vezes, parava e começava mas nunca desisti de compartilhar. Hoje gero conteúdo principalmente no Instagram e Youtube e agora aqui mais uma vez, escrevendo para um novo blog. Resumindo, colabore com outras pessoas e um dia isso volta pra você. Suas atitudes, sejam boas ou ruins, voltarão pra você de alguma forma.

Outra coisa que posso acrescentar que me ajudou na minha carreira, foi ser mais ativo nas empresas, dar minha opinião nos momentos de tomada de decisão e não apenas esperar que decidam tudo por mim.

E claro, melhoria contínua com cursos e estudos que sempre fiz por conta própria. Não espere que sua empresa invista em você, que a empresa te pague um curso ou que a empresa te dê tempo pra estudar. Se ela der, ótimo! Mas não conte com isso e seja dono da sua carreira.

E pra fechar, cuide da sua saúde, da sua vida pessoal e de seus relacionamentos. Tive momentos onde foquei demais na carreira e minha vida pessoal foi para o buraco. Você tem muito mais chances de ser um profissional melhor, quando se torna uma pessoa melhor.

Ficaria grato de saber se esse post te ajudou de alguma forma. E se algo não ficou muito claro, só deixar um comentário que eu te respondo e/ou atualizo o post.

Até a próxima!

Top websites to find a remote programming job

Frederico Maia — Wed, 29 Jan 2020 16:12:47 +0000

One of the first challenges to find a remote job is to discover where are the opportunities. Look at the websites below to find a remote job as Software Developer.

Stackoverflow
https://stackoverflow.com/jobs/remote-developer-jobs

We work remotely
https://weworkremotely.com/categories/remote-programming-jobs

RemoteOK
https://remoteok.io/remote-dev-jobs

Remotive
https://remotive.io/remote-jobs/software-dev

Jobspresso
https://jobspresso.co/remote-software-jobs/

Working Nomads
https://www.workingnomads.co/jobs?category=development

BairesDev
https://www.bairesdev.com/careers/

Toptal
https://www.toptal.com/developers/join

Glassdoor
https://www.glassdoor.com/blog/work-from-home-jobs-now/
https://www.glassdoor.com/blog/companies-that-let-you-work-remotely/

Findwork
https://findwork.dev/

Employ Remotely
https://www.employremotely.com/

Vanhack
https://vanhack.com/