Segundo uma pesquisa da Forbes, 68% das empresas no Brasil planejam aumentar as contratações de tecnologia em 2026.

Rachel Garcia, líder de talentos da Century na América Latina, disse o seguinte:

Praticamente todas as áreas terão que contratar e desenvolver mais gente para lidar com dados e inteligência artificial. Sem profissionais preparados para desenhar, integrar, operar e evoluir soluções de automação e digitalização de processos com qualidade, os ganhos de produtividade não vão se sustentar.

Ou seja, as vagas existem. E em quantidade.

Então por que você se candidata e não recebe resposta?

A resposta é simples, mas dói ouvir: faltam devs qualificados. Há um excesso de iniciantes sem preparo suficiente para o que o mercado exige hoje. O problema não está na demanda. Está na oferta. Tem muita gente tentando entrar ao mesmo tempo, mas pouca gente chegando preparada do jeito que as empresas precisam.

Isso cria uma situação paradoxal: empresas com vagas abertas há meses sem conseguir preencher, e desenvolvedores mandando currículo sem conseguir resposta. Os dois lados frustrados, mas por razões completamente diferentes.

Isso cria um ciclo vicioso que paralisa muita gente.

Sem experiência, ninguém te chama. E se ninguém te chama, você não ganha experiência.

E por que isso ficou tão difícil? Porque a linha de corte ficou muito mais rígida nos últimos anos.

Lá por 2017, 2018, 2019, se você soubesse o básico de Kotlin, conseguia uma vaga Android. A empresa te contratava e ensinava o restante internamente. Esse mercado existiu de verdade, e eu vi isso acontecer com vários alunos e conhecidos que entraram na área nessa época sem precisar de muito mais do que vontade e um conhecimento inicial sólido.

Mas aí veio 2020 e 2021, e o setor forçou contratações em massa. Muita empresa contratando rápido e sem filtro rigoroso, porque precisava crescer. Em seguida, 2022 e 2023 trouxeram as demissões em lote das bigtechs como Amazon, Meta e Google. Dezenas de milhares de devs experientes jogados no mercado ao mesmo tempo. A régua subiu muito. Saber o básico hoje é o mínimo, e ele não te destaca mais.

O que era nível pleno virou requisito de entrada. O que era diferencial virou obrigação. E quem não percebeu essa mudança continua tentando entrar com o padrão de 2019 num mercado de 2026.

Com isso, surgiram três problemas que provavelmente estão te afetando agora.

A descrição da vaga pede Kotlin, Jetpack Compose, arquitetura MVVM, integração com API REST, Firebase e ainda inglês.

Isso não é exagero. É o que o mercado espera de um júnior hoje.

Vou te dar um exemplo real de requisitos que aparecem em vagas "júnior" de Android no Brasil agora:

• Experiência com Kotlin e corrotinas
• Conhecimento de Jetpack Compose
• Entendimento de arquitetura MVVM ou MVI
• Familiaridade com injeção de dependências (Hilt ou Koin)
• Consumo de APIs REST com Retrofit
• Versionamento com Git
• Inglês para leitura de documentação

E em alguns casos ainda adicionam: testes unitários, CI/CD, Firebase, publicação na Play Store.

Isso é o que chamam de vaga júnior. Não é uma vaga para quem está aprendendo. É uma vaga para quem já aprendeu um volume considerável de coisa e consegue trabalhar com autonomia mínima desde o primeiro dia.

As empresas recebem centenas de candidatos por vaga. O recrutador não tem tempo de ler currículo por currículo com atenção. Quem não apresenta um pacote completo de conhecimento simplesmente é descartado antes mesmo de chegar na entrevista. Às vezes de forma automatizada, por palavras-chave que o sistema de triagem não encontrou no seu currículo.

Não é pessoal. É volume.

O segundo problema é que você sabe copiar código, mas não sabe programar de verdade. E isso não te destaca.

Você termina um curso de Kotlin. Depois faz um de Jetpack Compose. Depois acha um tutorial de MVVM no YouTube. Depois começa outro curso porque esse parecia mais completo. No final, não consegue criar nada do zero, sozinho, sem seguir um passo a passo.

Na programação, isso tem nome: tutorial hell, o inferno dos tutoriais.

O que acontece psicologicamente é o seguinte: enquanto você assiste a aula, tudo parece fazer sentido. O instrutor digita, o código funciona, você entende a lógica. Você sente que está aprendendo. Dá aquela sensação boa de progresso.

Mas aí você fecha o vídeo, abre o Android Studio numa tela em branco e trava.

Você não sabe por onde começar. Não sabe quais arquivos criar. Não sabe como estruturar o projeto. A sensação de entendimento que você tinha era real, mas era entendimento do que o instrutor estava fazendo, não da capacidade de fazer sozinho.

Isso tem um nome científico também: ilusão de competência. Você confunde reconhecimento com capacidade de execução. São coisas completamente diferentes.

O mercado quer alguém que saiba resolver problemas. Assistir tutoriais e resolver problemas são coisas completamente diferentes. Na entrevista técnica, ninguém vai pedir para você assistir uma aula e repetir o que o professor fez. Vão te dar um problema e pedir para você resolver.

A maioria das vagas nunca chega a ser publicada. As empresas contratam muito por indicação.

Quando você manda currículo pelo LinkedIn, você entra na fila disputando atenção na camada mais superficial do processo. Você compete com centenas de pessoas sem nenhuma vantagem além do papel.

Quem já tem conexões dentro da empresa chega antes mesmo da vaga existir. O dev que faz parte da comunidade, que já interagiu com aquele tech lead no GitHub ou no Discord, que apareceu no radar de alguém da empresa, tem uma vantagem enorme sobre quem manda currículo frio para o e-mail de RH.

Não é injusto. É como o mundo funciona. Em todas as áreas, não só em tecnologia.

O problema é que a maioria das pessoas que estão aprendendo a programar ficam 100% focadas no técnico e ignoram completamente a construção de presença. Estudam sozinhas, sem interagir com comunidade, sem mostrar o que estão construindo, sem aparecer em nenhum lugar que as pessoas da área frequentam.

Antes de falar das soluções, preciso te contar uma coisa sobre como funciona o processo seletivo na prática.

Um recrutador em uma empresa de médio porte pode receber de 200 a 500 currículos para uma vaga. O tempo dedicado a cada currículo na triagem inicial é, em média, de 7 a 30 segundos.

Nesse tempo, ele vai olhar para três coisas:

• Você tem os projetos e tecnologias que a vaga pede no currículo?
• Tem algo no GitHub ou portfólio que mostre código funcionando?
• O currículo é legível, objetivo e sem informação irrelevante?

Se qualquer uma dessas três perguntas tiver resposta negativa, seu currículo vai para o descarte. Sem leitura aprofundada, sem chance de explicar no telefone, sem nada.

Isso muda completamente o que você precisa focar. Não adianta ter estudado muito se isso não estiver visível e comprovável de forma imediata no seu currículo e no seu GitHub.

O tutorial é uma ferramenta boa, mas você provavelmente não está usando ele da melhor forma.

O passo que falta é este: pare de acumular cursos e comece a construir algo real com o que você já aprendeu.

Não precisa ser nada complexo. Um app de agendamento de barbearia. Um sistema de controle de estoque para uma loja. Um gerenciador de tarefas pessoais. Um app de acompanhamento de gastos. Qualquer coisa que resolva um problema real e que obrigue você a tomar decisões técnicas sozinho.

O ponto mais importante é sair da posição passiva de quem assiste e entrar na posição ativa de quem constrói.

Você não precisa de carteira assinada para ter experiência. Você constrói algo que funciona, resolve um problema real e toma decisões técnicas. Isso sim é experiência.

A diferença entre um projeto de tutorial e um projeto de portfólio é essa: no tutorial, você seguiu as instruções de outra pessoa. No projeto próprio, você encarou um problema, tomou decisões de arquitetura, resolveu bugs sem ter a resposta pronta, e fez funcionar. Isso é o que o entrevistador quer ver.

Quando você constrói algo do zero, inevitavelmente vai esbarrar em situações que o tutorial não cobriu. E é exatamente nesses momentos que você aprende de verdade: como ler a documentação oficial, como pesquisar erros no Stack Overflow, como entender a mensagem de erro e inferir a solução. Essa capacidade de resolver problemas sem depender de alguém é o que o mercado paga.

Para sair do tutorial hell de vez, você precisa de um treinamento que te faça praticar desde o início, não só assistir aulas. Por isso eu criei minhas formações de Android e iOS, com dezenas de módulos, centenas de aulas práticas e projetos reais que vão do zero à publicação na loja.

Tem gente desperdiçando meses em tecnologias que quase ninguém usa no mercado.

Kotlin lidera o volume de vagas Android. Swift ainda domina o iOS. Mas a linguagem sozinha não basta, e é aqui que a maioria das pessoas erra a estratégia de estudo: para em saber a sintaxe da linguagem e acha que está pronto para se candidatar.

O mercado quer quem sabe trabalhar com o ecossistema completo. Para Android, isso significa:

• Jetpack Compose para construção de interfaces declarativas
• Arquitetura MVVM para separar responsabilidades e manter o código testável
• Hilt ou Koin para injeção de dependências
• Retrofit para consumo de APIs REST
• Room para persistência de dados local
• Coroutines e Flow para operações assíncronas
• Git para versionamento, porque trabalho em equipe exige isso
• Publicação na Play Store, porque mostra que você vai até o fim

Para iOS, o equivalente é Swift com SwiftUI, arquitetura MVVM ou Clean Architecture, Combine ou async/await, URLSession ou Alamofire para APIs, CoreData ou SwiftData para persistência local e publicação na App Store.

O que eu aconselho é escolher uma dessas plataformas, ir fundo, e dominar esse conjunto de ferramentas de verdade antes de tentar diversificar. Profundidade numa área vale muito mais do que superficialidade em várias.

O que as empresas mais buscam hoje não é só quem sabe programar. É quem sabe pensar.

Na prática, o problema chega como uma regra de negócio: o cliente precisa de X. A sua função é traduzir isso em código pensando no impacto para o negócio. Mas entre o pedido do cliente e a linha de código existe um gap enorme, e preencher esse gap é o que diferencia um dev que só executa de um dev que resolve problemas.

Treine isso nos seus projetos com uma prática simples: antes de abrir o editor de código, escreva num papel ou num arquivo de texto:

• Qual problema este app resolve?
• Quem é o usuário que vai usar isso?
• O que ele precisa conseguir fazer em menos de 3 cliques?
• Qual seria o fluxo mais simples possível para resolver esse problema?

Isso muda completamente a qualidade do que você vai construir. E muda a qualidade das respostas que você dá numa entrevista quando o recrutador pergunta: "me conta um projeto que você fez e qual problema ele resolvia".

A maioria dos candidatos responde com tecnologia: "fiz um app com Retrofit e MVVM". O candidato que se destaca responde com problema e solução: "criei um app para uma barbearia que perdia clientes por falta de agendamento organizado, e desenvolvi um sistema que permite ao cliente agendar pelo celular em menos de um minuto".

Pare de pensar só como desenvolvedor. Pense como dono do produto.

Essa solução pode mudar bastante seu jogo financeiro, e ela é mais acessível do que a maioria das pessoas imagina.

Um dev Android ou iOS com inglês consegue trabalhar para empresas nos Estados Unidos e na Europa sem sair de casa. Plataformas como Toptal, Turing, Contra e Arc têm projetos mobile pagando em dólar o tempo todo. A diferença salarial entre um dev que atende só o mercado brasileiro e um que atende o mercado internacional pode ser de 3x a 5x, dependendo da senioridade e da empresa.

Além disso, a maioria das documentações oficiais do Android e do iOS, os fóruns técnicos, as conferências e os conteúdos mais aprofundados estão em inglês. Quem não entende inglês técnico sempre fica um passo atrás, porque vai depender de alguém que já leu a fonte original e traduziu, com todos os filtros e atrasos que isso implica.

E você não precisa ser fluente. Comece pelo inglês técnico com materiais que você já usa:

• Documentação oficial em developers.android.com e developer.apple.com
• Stack Overflow
• Vídeos e canais em inglês no YouTube sobre Android e iOS
• Servidores no Discord da comunidade de desenvolvimento mobile
• Changelog das releases do Kotlin, Swift e das ferramentas que você usa

Com 30 minutos por dia dedicados ao inglês técnico, em seis meses você já consegue ler documentação sem dificuldade. Em um ano, consegue participar de entrevistas em inglês. A diferença salarial vai aparecer mais rápido do que você imagina.

Voltando ao terceiro problema: a falta de network.

A boa notícia é que nunca foi tão fácil construir presença e conexões genuínas na área de tecnologia como é hoje, sem precisar de uma empresa, de um evento físico ou de qualquer investimento financeiro.

O que funciona na prática:

GitHub ativo. Coloque seus projetos no GitHub, mesmo que sejam simples. Um perfil com projetos commitados regularmente mostra que você está trabalhando, evoluindo e tem código para mostrar. Um perfil vazio ou com apenas um repositório diz o contrário.

LinkedIn com conteúdo. Você não precisa postar todo dia. Mas postar uma vez por semana sobre o que você está aprendendo ou construindo te coloca no radar de pessoas da área. Recrutadores monitoram perfis que produzem conteúdo. É diferente de mandar candidatura fria.

Comunidades no Discord e Telegram. Existem servidores dedicados a desenvolvimento Android, iOS e mobile em geral com milhares de devs ativos. Participar, tirar dúvidas, responder dúvidas dos outros te constrói reputação ao longo do tempo. Pessoas que te conhecem numa comunidade podem te indicar para uma vaga que nem chegou a ser publicada.

Comentar e contribuir. Quando você aprende algo novo a partir de um artigo ou vídeo, comentar com uma observação genuína ou uma dúvida real gera visibilidade e começa relacionamentos. Isso funciona no YouTube, no LinkedIn e no próprio GitHub.

Network não é distribuir cartão de visita digital. É aparecer consistentemente em lugares onde as pessoas da sua área estão, agregar valor com o que você sabe e pedir ajuda com o que ainda não sabe. As indicações vêm naturalmente depois disso.

O portfólio é o que transforma todo o esforço das soluções anteriores em algo que o recrutador consegue avaliar em 30 segundos.

Não precisa de um site elaborado, embora ter um seja um diferencial. O que realmente importa é o GitHub bem organizado com projetos que mostram domínio do ecossistema que você escolheu.

Para cada projeto no seu portfólio, você precisa de:

README completo. Descreva o que o app faz, qual problema ele resolve, quais tecnologias você usou e por que escolheu cada uma. Coloque screenshots ou um GIF mostrando o app funcionando. Isso mostra que você pensa além do código, que consegue comunicar o que construiu.

Arquitetura visível. Organize o projeto em camadas claras (data, domain, presentation). Quem abre o repositório precisa entender a estrutura em menos de um minuto. Um projeto organizado comunica que você entende de boas práticas, mesmo sem ler uma linha de código.

Histórico de commits coerente. Commits com mensagens como "fix" ou "update" não dizem nada. Commits com mensagens como "add Room database for offline caching" ou "refactor ViewModel to use StateFlow instead of LiveData" mostram que você entende o que está fazendo e por quê.

App publicado quando possível. Um link para o app na Play Store ou App Store no README é um diferencial enorme. Mostra que você foi até o fim, que o projeto é real e que você sabe como funciona o processo completo de publicação.

Dois ou três projetos bem feitos valem muito mais do que dez projetos abandonados ou clones de tutorial sem nenhuma personalização.

O mercado não está fácil, é fato. Mas os dados mostram que as vagas existem e em quantidade.

O que falta não é oferta de emprego. O que falta são profissionais que chegam preparados do jeito certo, com projetos reais para mostrar, com o ecossistema dominado, com alguma presença na comunidade e com capacidade de resolver problemas de forma independente.

A linha de corte mudou, infelizmente. Mas quem entende isso e age de acordo sai na frente de 90% dos concorrentes, porque a maioria ainda está tentando entrar no mercado com a estratégia de 2019.

Se você seguir os caminhos que apresentei aqui, vai estar muito mais perto da sua primeira vaga como dev do que a maioria dos candidatos que manda currículo todo dia sem nenhuma estratégia:

• Construa projetos reais que resolvem problemas reais
• Domine o ecossistema completo da plataforma que escolheu
• Pense como dono do produto, não só como executor de código
• Invista no inglês técnico de forma consistente
• Apareça na comunidade e construa presença ao longo do tempo
• Monte um portfólio que fala por você antes da entrevista acontecer

Conseguir a primeira vaga como dev não vai ser simples. Mas é totalmente possível, e tem acontecido com pessoas que saíram do zero e seguiram um caminho estruturado e consistente.

O problema nunca foi falta de vaga. Foi falta de preparo que chegasse ao nível que o mercado passou a exigir.

Se quiser um caminho estruturado para dominar Android ou iOS com projetos reais do zero à publicação na loja, conheça meus treinamentos de Android e iOS. São as formações que eu criaria para mim mesmo se estivesse começando hoje.

Você talvez já tenha lido meu texto sobre KISS. O princípio continua o mesmo:

Keep it simple, stupid.

Quanto mais simples, mais claro. Quanto mais claro, mais fácil de manter. Quanto mais fácil de manter, mais energia sobra para construir o que realmente tem valor… o conteúdo!

Este próprio site é uma aplicação prática disso.

Eu não quero transformar o blog em um projeto paralelo de decoração digital. Quero que ele seja uma ferramenta direta para publicar ideias, ensinar programação e compartilhar experiência real de quem escreve software há anos.

Se o texto carrega a mensagem, se o código do site é fácil de manter e se o leitor consegue chegar rapidamente ao conteúdo, então o objetivo foi cumprido.

Nem todo projeto precisa de uma arquitetura visual exuberante ou de uma solução sofisticada. Em muitos casos, a solução simples não é apenas suficiente. Ela é superior.

Outro princípio que conversa diretamente com essa decisão é o YAGNI:

You Aren't Gonna Need It - Você Não Vai Precisar Disso.

Traduzindo para a prática: não adicione agora aquilo que não resolve um problema real agora.

Isso vale para código. Vale para arquitetura. Vale para features. E vale também para layout.

Eu não preciso de vinte efeitos visuais para ensinar alguém a programar uma tela no Android ou estruturar uma lógica no Swift.

Eu não preciso de uma experiência visual carregada para explicar orientação a objetos, estado, listas ou arquitetura de software.

Se algo não aumenta a clareza, não melhora a leitura e não ajuda o aluno a avançar, existe uma boa chance de ser excesso.

Excesso custa caro.

Custa tempo. Custa energia. Custa manutenção. Custa foco.

E o pior: muitas vezes ele dá uma falsa sensação de progresso.

Você passa a tarde inteira mexendo em detalhes superficiais e no fim do dia não escreveu uma linha melhor de código, não aprendeu nada novo de lógica e não terminou nenhum programa.

Eu aprendi isso cedo com um mentor oriental que marcou bastante a minha forma de pensar.

Ele era o tipo de pessoa extremamente disciplinada, objetiva e econômica em palavras. Não falava mais do que precisava. Não complicava o que podia ser direto. E me ensinou uma coisa que ficou comigo:

Quando o essencial está fraco, o enfeite vira distração.

Isso não era só sobre programação. Era sobre postura profissional.

• Antes de querer impressionar, entregue;
• Antes de embelezar, faça funcionar;
• Antes de sofisticar, simplifique;
• Antes de expandir, domine o básico.

Essa mentalidade mudou minha forma de construir software.

Eu parei de admirar soluções complicadas só porque pareciam inteligentes. Passei a respeitar muito mais a solução que funciona, é legível, é enxuta e continua fácil de evoluir meses depois.

E honestamente, isso também me ajudou fora do código.

Hoje eu prefiro uma rotina mais simples, ferramentas mais diretas e processos mais leves quando o objetivo é produzir melhor.

Menos teatro. Mais entrega.

Se você está aprendendo a programar, eu quero te passar uma ideia muito prática:

Não confunda movimento com progresso.

Trocar tema do editor toda semana não é programar.

Ficar obcecado com setup perfeito não é programar.

Assistir infinitos vídeos sobre programação sem construir nada, você já sabe… também não é programar.

Programar é sentar e escrever código. É testar. É errar. É depurar. É melhorar aos poucos. É criar um programa, mesmo pequeno, e terminar.

Muita gente se perde nas bordas da profissão.

Quer o melhor teclado, a melhor fonte, o melhor tema, a melhor linguagem, o melhor framework, a melhor stack, a melhor metodologia, o melhor segundo cérebro, o melhor plugin, a melhor IA, o melhor roadmap.

Mas evita o principal: abrir o projeto e fazer o trabalho.

Se você levar KISS e YAGNI a sério, muita coisa desnecessária cai por terra.

Você para de enfeitar o que ainda nem existe e para de construir complexidade antes da hora.

Assim, você não gasta energia tentando parecer programador e começa, de fato, a programar.

Simplicidade não significa descuido, fazer qualquer coisa ou abandonar qualidade.

Simplicidade de verdade exige critério. Exige intenção. Exige saber dizer “não” para muita coisa que até poderia entrar, mas não deveria entrar.

Este site é simples porque ele foi pensado para ser assim.

Eu, Tiago, quero focar no que importa: escrever, ensinar, programar e construir coisas úteis.

E você, leitor, pode aplicar a mesma lógica na sua jornada.

Comece retirando vaidade técnica, distrações ou enfeite prematuro.

E aplique mais prática, código, projetos terminados e foco no essencial.

No fim, é isso que faz alguém evoluir de verdade.

Se este texto te ajudou a refletir, continue acompanhando os conteúdos. A proposta aqui é exatamente essa: menos fumaça e mais conteúdo útil para você aprender a criar software de verdade.

Bom dia Tiago! Depois dá uma olhada no app que eu concluí no iOS legacy… projeto final do curso

— Maxwell Farias - Aluno

A finalidade do aplicativo é trazer uma lista de produtos em que o usuário pode fazer a recuperação de um cupom. E ao fazer a compra deste produto, conseguir um desconto na loja.

Muito bom o curso.

— Adriano Valumin - Aluno

Este aplicativo foi criado para que todos possam criar seus hábitos diários.

— Heverson Assunção - Aluno

Opa Tiago depois de alguns dias batendo cabeça consegui dar um jeito e finalizar o app apesar de simples foi trabalhoso ainda mais pra mim que estou começando, mas novamente sem suas dicas e ajuda eu não estaria aqui, obrigado novamente e vamos para o terceiro app!

Aplicativo que ajuda você à monitorar os principais indicadores de saúde como consumo de água, taxas metabólicas e farmácias próximas.

— Ygor Doring - Aluno

Fala Tiagão, tudo certo? Gostaria de agradecer por mais esse módulo e dizer que estou a ponto de conseguir minha primeira oportunidade como android developer em uma big tech. Graças a você e ao conteúdo de primeira que temos no curso! Agradeço imensamente pelo conhecimento e boa vontade em ajudar!.

Aplicativo que ajuda você à monitorar os principais indicadores de saúde como consumo de água, taxas metabólicas e farmácias próximas.

— Sérgio Silveira - Aluno

Tiago, primeiro de tudo quero agradecer imensamente todo o suporte dado durante o curso com minhas dúvidas, estou colocando meus projetos em um outro patamar, graças as técnicas, recursos e o conhecimento compartilhado por você e toda sua equipe. Obrigado mais uma vez, o Curso Android Express de fato foi um divisor de águas na minha carreira profissional… estou apaixonado pelo kotlin. Obrigado e vamos em frente.

Aplicativo de vendas da Empresa.

— Felipe Matheus - Aluno

Boa tarde pessoal, tenho orgulho de vir aqui publicar que graças as habilidades que aprendi durante o curso, pude fechar uma parceria com a principal igreja da minha cidade e desenvolver o app Desterro Mairiporã.

Este é o aplicativo da Igreja de Mairiporã.

…Para quem mora em Mairiporã vai adorar o controle dos transportes..

— Felipe Ferreira - Aluno

Esse aplicativo controla os transportes na palma da mão e ajuda você a se programar melhor durante a semana :)

— Leandro Modena - Aluno

Tiago, estou super feliz, depois do seu curso e com muita dedicação e estudo terminei meu app que está na loja (Emprego Azul +500 downloads), consegui vários serviços de freelance e amanhã será meu primeiro dia com carteira registrada como Desenvolvedor Android.

O aplicativo ajuda a encontrar empregos e serviços em gerais.

— Thiago Oliveira - Aluno

O aplicativo ajuda a monitorar alguns indicadores importantes para a saúde do indivíduo.

..Subi um jogo na Google play… consegui com os conhecimentos do curso

— Flazion Lima - Aluno

Um simples mas desafiador jogo de quebra-cabeças de blocos de jóias! Block Puzzle 2020 é um quebra-cabeça totalmente gratuito. Você pode apreciá-lo em qualquer lugar, sempre, sem necessidade online. Este jogo offline tem um jogo muito simples: basta arrastar, soltar e preencher toda a grade

Fala,Tiago Blz? Pessoal da empresa deu um retorno. Fui contratado como Programador Jr. Valeu pela força.

— Hemerson Silva - Aluno

O aplicativo agrega uma coleção de filmes onde você poderá favoritar para serem assistidos futuramente.

Segue um app que fiz pra ajudar no combate a COVID-19 na região onde moro. O app informa o boletim das 18 cidades da região.

— Hemerson Silva - Aluno

O aplicativo faz um boletim das 18 cidades de Pajeú com status da pandemia.

Com o seu curso eu pude de fato aprender algo com um cronograma e mesmo nas aulas básicas eu sempre vejo coisas que se eu já soubesse iria facilitar muito a minha vida. Por isso não pulo nenhuma aula e vejo todas desde os fundamentos. Por isso a importância de se começar com calma e ir avançando gradativamente.

— Ângelo Robson - Aluno

Encontre um ponto turístico mais próximo de você e conheça as belezas naturais do estado de Alagoas. Com o AL Turismo você poderá analisar fotos, distância e rotas até o destino desejado.

Boa tarde pessoal, sou aluno do curso também. Desenvolvi um APP que consome dados de uma API que extrai os dados do ministério da saúde quanto ao status do covid-19.

— Ângelo Robson - Aluno

Aplicativo desenvolvido para fornecer informações confiáveis ​​sobre o status do vírus.

_\_Devido ao assunto delicado do Covid-19, o o Google Play não aceita apps neste gênero, exceto de instituições oficiais de saúde. Contudo, você pode acompanhar pelo código-fonte aberta pelo desenvolvedor.*

Estou passando aqui para agradecer seus videos, pois comprei seu curso fora o que fiz de graça no youtube, então especialmente este que usa a API do Google Maps. Depois de concluído resolvi criar meu portfólio. Estou pra upar na google play um Segundo App que fiz estudando seu curso.

— Paulo Soares - Aluno

Este aplicativo foi criado para que todos possam saber em tempo real onde teve Roubos e Assaltos na região onde você estar, com ele será possível fazer o mapeamento da cidade e saber qual região com maior índice de roubos, somos um aplicativo novo e totalmente independente apenas com intuito de ajudar as pessoas a quem sabe encontrar seus bens ou inibir algum roubo seja de celular, veículo ou qualquer outra coisa.

Minha trajetória teve início em meio a uma família simples, permeada pelo ofício de eletricistas. Meu pai, irmãos e primos, todos trilhavam esse caminho, e tudo apontava para o fato de que eu seguiria a mesma rota.

E, de fato, assim aconteceu.

Com uma formação em eletroeletrônica pelo SENAI, meu conhecimento tecnológico estava inicialmente atrelado a hardware, diodos, transistores e resistores.

Contudo, foi quando dei meu primeiro mergulho na programação que tudo mudou, utilizando uma linguagem de baixo nível: o Assembly.

Iniciei minha jornada aprendendo a programar em Assembly, explorando a criação e automação de tarefas com microcontroladores da família 8051. Mais tarde, adentrei o universo da linguagem C, especialmente voltada para microcontroladores PIC.

O ato de escrever um programa de computador fez meu coração cantar e acendeu o desejo de me tornar um desenvolvedor de software.

Ao ingressar na Universidade São Judas Tadeu, em São Paulo, como bolsista pelo programa Prouni, escolhi a Ciência da Computação como meu campo de estudo.

Após intensa dedicação, conquistei meu primeiro emprego em uma fábrica de software, onde desenvolvi soluções utilizando a linguagem Java após passar por três entrevistas técnicas desafiadoras.

Em um ponto crucial, optei por trilhar um caminho diferente, largando a universidade, apesar de já estar atuando como desenvolvedor backend. Ao adquirir experiências notáveis em empresas de renome, como a LATAM, continuei minha jornada, focando no desenvolvimento web.

Após alguns anos, vivi um momento decisivo que marcou uma verdadeira virada como programador.

O ano era 2013.

Trabalhava em uma empresa de telemetria onde tive contato com algumas pessoas que estavam embarcando no universo mobile.

Aquilo parecia mágico 🎩.

Com isso, decidi mudar drasticamente de especialização e seguir uma nova jornada para me tornar um desenvolvedor mobile com Android e trabalhar como freelancer e desenvolvedor independente, criando meus próprios aplicativos, empreendendo.

Criei diversos aplicativos em diversos nichos de mercado:

• e-commerce
• financeiro
• imobiliários
• CRM
• jogos de azar
• educaional
• fitness
• infantil
• streams
• redes sociais

Vivi alguns anos somente com a renda dos meus próprios aplicativos Android. Mas em um determinado momento, eu senti que precisava ir para outro nível. Eu precisava me tornar um desenvolvedor mobile completo, com Android e iOS.

De 2015 à 2018, fui coordenador de um time de desenvolvimento e em paralelo comecei a "respirar" somente iOS - dia e noite.

Com essa vontade irrazoável em aprender e me tornar um desenvolvedor mobile completo, agora no universo iOS, crio minha própria oportunidade e lanço um desafio de 90 dias para meu CTO.

Modernizar um aplicativo de Objective-C para Swift.

Este era o aplicativo iOS principal da empresa que foi categorizado como os top aplicativos do setor imobiliário.

Esse processo precisava ser feito do absoluto zero e em até 90 dias.

Só tinha um pequeno problema, eu não sabia ABSOLUTAMENTE nada de Objective-C ou Swift. Muito menos instalar o Xcode 😱.

Mas eu sabia resolver problemas, sabia aprender e sabia que era capaz e teria êxito!

Tudo isso enquanto trabalhava e cuidava de outras coisas na empresa, afinal, nada pode parar não é mesmo?

Toquei este projeto sozinho e para a felicidade de todos, 88 dias depois (2 dias a menos do prazo estipulado) o projeto estava pronto e publicado na App Store.

Tudo isso foi possível por causa do meu desejo irrazoável de fazer acontecer e de querer levar minhas habilidades para o próximo nível.

Em 2018, decidi compartilhar no Youtube os meus conhecimentos sobre desenvolvimento Android e iOS nativos.

Hoje, esse canal possui +4.0 milhões de Views e +69.000 seguidores (e contando).

Este é considerado o maior canal sobre desenvolvimento Android e iOS nativo do Brasil.

E a pedido de milhares de inscritos, eu comecei um novo projeto ministrando treinamentos online para transformar os aspirantes à programadores (iniciantes), assim como eu fui um dia, em desenvolvedores profissionais.

Com esse projeto, eu já ajudei mais de 4.000 alunos a aprenderem a programar de verdade com meus treinamentos online.

Hoje, minha missão é ajudar ainda mais pessoas como você, através das minhas experiências reais a se tornarem desenvolvedores mobile extraordinários.

Além disto, através de artigos do blog, e-books e materiais gratuitos, irei compartilhar a minha experiência e o que eu faço no dia-a-dia para desenvolver aplicativos Android e iOS e espero que isso possa te ajudar.

Eu acredito que qualquer pessoa tem o potencial de se tornar um desenvolvedor extraordinário capaz de criar uma obra de arte na forma de produto/software.

De fato, estou frustrado com a falta de conhecimento, comprometimento e prática de muitos programadores que preferem se manter na média ao invés de evoluir para o próximo nível buscando a excelência do seu trabalho e da sua vida.

Espero que você esteja em busca de se destacar no mercado e não ser mais um no meio da multidão de outros programadores.

Se você, assim como eu e diversos alunos de sucesso, quiser sair da sua zona de conforto para mudar de vida e de carreira, eu te convido a mergulhar de cabeça e fazer uma imersão nesse universo Android ou iOS.

Eu criei o caminho mais efetivo possível depois de anos de experiência, onde você pode aprender de verdade como criar aplicativos profissionais com nossos treinamentos online.

Clique aqui para saber mais.

Seguir um mentor, deixará a sua trajetória mais fácil e te economizará muito tempo e dinheiro.

"Mas Tiago, ainda estou com algumas dúvidas:"

• O que é preciso para evoluir minhas habilidades como desenvolvedor mobile?
• O que preciso saber para trabalhar exclusivamente como um programador que cria aplicativos diferenciados?
• Como ser reconhecido no mercado e ter uma carreira de programador de sucesso?
• Como começar?
• Mas é difícil?

Criar aplicativos é mais simples que você possa imaginar, mas isso não significa que é fácil ou que você não vai precisar se dedicar.

Há um passo a passo que você pode aprender, alguns desses passos inclui:

• Arquiteturas de software
• Produtividade
• Ferramentas e métodos
• Concepção de ideias para aplicativos

A boa notícia é que existe um método assertivo para aprender tudo isso, de forma estruturada e organizada.

Olhando de uma visão bem ampla, temos 3 grandes tópicos para aprender:

1. Linguagem de Programação
2. Android ou iOS SDK
3. Método/Processos

Esses são os 3 pilares para se aprender qualquer tecnologia, incluindo criar aplicativos.

Dentro dos meus treinamentos online, eu mostro passo a passo como aprender cada um desses pilares.

Clique aqui para saber mais.

Aprender a programar e criar aplicativos pode ser difícil para muita gente. Agora, compartilhar o conhecimento de forma clara pode ser mais difícil ainda!

Por isso, ao invés de eu mesmo falar sobre os resultados que gerei e as vidas que já pude transformar, vou deixar aqui os relatos de pessoas que confiaram no meu trabalho e hoje estão decolando em suas carreiras.

Veja o que algumas das milhares de pessoas que já passaram pelos nossos cursos online de programação dizem sobre.

Ao reconhecer a distinção entre simples "programadores" e verdadeiros profissionais, você abrirá caminho para se destacar e alcançar o reconhecimento merecido. Este é o primeiro passo para conquistar aquilo que verdadeiramente merece.

O conceito de ganhar pouco ou muito é subjetivo, variando de mil a dez mil reais conforme as perspectivas individuais.

A quantia que almeja no mercado e em sua carreira é uma decisão pessoal que recai exclusivamente sobre você.

É fundamental compreender que todo indivíduo que atingiu o sucesso, conforme sua própria definição, iniciou sua trajetória a partir do zero. Portanto, seja você, eu ou qualquer outra pessoa, temos a capacidade de começar do zero e construir nosso caminho.

Posso assegurar que trilhar o caminho de desenvolvedor mobile pode proporcionar uma qualidade de vida incrível.

Eu acredito verdadeiramente que, depois de 15 anos de experiência como desenvolvedor eu possa te ajudar de alguma forma a evoluir na sua carreira mobile.

Espero que você aprenda muito por aqui e que meu conteúdo possa te ajudar a ir para o próximo nível.

Se você deseja me contactar:

• Instagram
• Youtube
• Facebook

Todo desenvolvedor começou exatamente onde você está agora. Os primeiros passos não precisam ser perfeitos, eles só precisam ser claros. Nesta primeira etapa, o foco é entender o ambiente, escrever sua primeira linha de código e reconhecer como o Kotlin se comporta.

Você não precisa de formação em computação para acompanhar. Precisa apenas de uma ferramenta para escrever e executar código Kotlin, como o Playground Kotlin, Android Studio ou uma IDE compatível com Kotlin. O importante agora é ter um lugar para testar ideias rapidamente.

IDE: Integrated Development Environment. É o Ambiente de Desenvolvimento Integrado, isto é, a ferramenta que fornece um kit para o programador programar.

No fim desta etapa, você vai entender como um programa Kotlin é organizado, como o código é executado e por que os primeiros exemplos parecem simples, mas são a base de tudo o que vem depois.

Quando comecei em 2009, eu estava criando programas para microcontroladores da família 8051 usando linguagem assembly. E sabe qual era meu único recurso de aprendizado? Livros. Literalmente só livros.

Não tinha: - tutoriais em vídeo; - bootcamps presenciais; - cursos online; - mentores disponíveis; - comunidades no Discord; - YouTubers;

Não tinha ninguém explicando passo a passo como resolver aquele bug específico que estava me atormentando há horas.

O recurso era escasso. Extremamente escasso até.

E isso me forçou a fazer uma coisa que hoje percebo que foi valiosa demais: explorar por conta própria. Testar, errar, quebrar coisas, consertar, quebrar de novo e desenvolver aquela capacidade de resolver problemas sem ter alguém segurando sua mão o tempo todo.

Mas vou ser honesto com você. Essa exploração toda teve um custo enorme: tempo.

Muito tempo perdido tentando achar a informação correta.

Muitas horas batendo cabeça em problemas que alguém mais experiente resolveria em minutos e momentos onde eu nem sabia se estava indo pelo caminho certo.

Foi um aprendizado profundo? Sim.

Foi eficiente? Discutível.

Agora vamos para 2025. O cenário não poderia ser mais diferente.

Você tem tutoriais em vídeo para absolutamente tudo. Tem inteligência artificial que te ajuda a debugar código e entender conceitos teóricos. Tem comunidades gigantescas no Discord, Slack, Reddit e tem mentores fazendo mentorias e ainda documentação detalhada.

Parece o paraíso, não é? Finalmente temos acesso ilimitado a conhecimento de qualidade.

Mas aqui está o problema que poucos admitem: isso virou uma grande desvantagem.

Explico.

A informação está completamente espalhada pela internet. Você assiste um tutorial no YouTube sobre Python, depois lê um artigo sobre JavaScript e já vai correndo vê alguém falando que Rust é o futuro e, no fim do dia, aparece um anúncio de bootcamp de Data Science.

E você fica ali, pulando de um conteúdo para outro, consumindo informação infinitamente mas sem realmente conectar os pontos. Sem entender como as coisas funcionam de verdade e sem criar um conhecimento sólido que você pode aplicar.

É como ter todas as peças de dez quebra-cabeças diferentes misturadas na sua frente.

Você tem muitas peças, mas não consegue montar nenhum quebra-cabeça completo.

Se eu estivesse começando hoje, sabendo o que sei agora, aqui está exatamente o que eu faria.

Aquela exploração que eu fiz forçado em 2009, porque não tinha outra opção, me ajudou demais a desenvolver habilidades críticas.

Me ensinou a resolver problemas sozinho quando não tem ninguém disponível para ajudar.

Me forçou a ler documentação técnica mesmo quando era confusa, me desenvolveu paciência para debugar erros complexos e criou autoconfiança de que consigo descobrir as coisas mesmo sem ter todas as respostas prontas.

Essas habilidades são insubstituíveis. Elas são o que separa um programador mediocre de um programador realmente bom.

Mas se eu tivesse tido um curso estruturado naquela época? Eu teria pegado esse conhecimento de forma muito mais rápida e eficiente, e aí sim exploraria em cima dessa base sólida.

Não teria perdido tanto tempo batendo cabeça em coisas que alguém poderia ter me explicado em minutos, mas ainda teria desenvolvido aquela capacidade de exploração e resolução independente de problemas.

Se eu fosse resumir minha estratégia ideal para aprender programação hoje em um processo simples, seria este:

Aprende um conceito novo com seu mentor através do curso ou bootcamp. Entende a teoria, vê os exemplos, faz os exercícios propostos.

Aí você para e explora aquilo profundamente. Cria três projetos diferentes aplicando aquele mesmo conceito. Tenta resolver problemas reais que você tem usando aquele conhecimento. Pesquisa outras formas de fazer a mesma coisa. Experimenta, erra, aprende.

Depois volta pro curso, aprende o próximo conceito. E repete o ciclo.

Aprende um pouquinho, explora bastante. Aprende mais um pouquinho, explora bastante. Continuamente.

Se você quer se aprofundar em desenvolvimento mobile comigo, especificamente Android ou iOS, eu criei treinamentos completos do zero ao profissional em pacotes com tudo que aprendi nesses 14 anos.

São cursos onde eu te guio exatamente pela progressão que funciona, com projetos práticos que constroem um em cima do outro, te ensinando não só a sintaxe mas como pensar como desenvolvedor mobile.

É literalmente um download mental de tudo que fiz como desenvolvedor Android e iOS, especialista nessas duas tecnologias. Todo o conhecimento que levei anos para construir, organizado numa sequência lógica que te leva do iniciante absoluto ao profissional empregável.

E não é só teoria minha. Tem centenas de alunos que saíram do absoluto zero e hoje estão decolando na carreira, bem remunerados, criando aplicativos de todo nicho que você possa imaginar.

Os depoimentos e projetos deles estão lá na página dos cursos.

Se isso faz sentido para você, se você quer um caminho estruturado sem ficar perdido na infinidade de informação da internet, considere conhecer meus treinamentos de Android e iOS.

Deixa eu te explicar a teoria de forma direta. O apply nada mais é do que uma função onde você pode usar qualquer objeto dentro do Kotlin para retornar ele mesmo e fazer configurações nesses objetos.

É uma forma de inicializar objetos de uma maneira mais legível e flexível.

Parece complicado? Vou te mostrar o modo tradicional e o modo com apply para você ver a diferença na prática.

Vamos supor que você tem uma estrutura de dados simples, um data class que é muito comum ter em qualquer projeto:

data class Usuario(
    var nome: String = "",
    var email: String = "",
    var altura: Double = 0.0
)

Qual que é o jeito tradicional de criar esse objeto e configurar as propriedades dele?

val userA = Usuario()
userA.nome = "Tiago"
userA.email = "tiago@exemplo.com"
userA.altura = 1.75

Funciona perfeitamente, sem problemas. Mas perceba que você está repetindo userA toda vez que quer acessar uma propriedade. E se você tiver 10, 15 propriedades para configurar? Vai ficar bem repetitivo.

Agora veja como fica com apply:

val userB = Usuario().apply {
    nome = "Tiago"
    email = "tiago@exemplo.com"
    altura = 1.75
}

Muito mais limpo, né? Você não precisa ficar repetindo o nome da variável toda hora. Dentro do bloco do apply, você já tem acesso direto às propriedades e funções do objeto.

Agora, uma pergunta importante: tem alguma grande vantagem em fazer isso com um objeto pequeno como eu te mostrei?

Não necessariamente. Para três propriedades simples, tanto faz. Você poderia ter usado o jeito tradicional sem problema nenhum.

A grande vantagem do apply aparece quando você está lidando com configurações mais complexas, com múltiplas propriedades para definir.

Imagine que você tem uma classe de configuração de banco de dados com 15 propriedades diferentes. Ou uma classe de requisição HTTP com várias opções. Aí sim faz muito mais sentido usar o apply para organizar tudo.

O objetivo principal dele é criar objetos seguindo o padrão builder, que é um padrão de design muito usado para construção de objetos complexos.

Uma coisa importante para você entender: dentro do bloco do apply, você tem a referência para o próprio objeto.

Para ser mais explícito, você poderia escrever assim:

val user = Usuario().apply {
    this.nome = "Tiago"
    this.email = "tiago@exemplo.com"
    this.altura = 1.75
}

Viu o this ali? É a referência para o objeto que foi criado. Mas o Kotlin é esperto o suficiente para entender isso automaticamente, então você não precisa escrever this toda vez. É implícito.

Vamos ver um exemplo mais real de como usar o apply para configurações:

val config = mutableMapOf<String, String>().apply {
    put("tema", "escuro")
    put("idioma", "pt-BR")
    put("ambiente", "producao")
}

Olha como ficou legível! Você criou um mapa de configurações e já inicializou ele com os valores, tudo de forma clara e organizada.

Isso é muito melhor do que criar o mapa e depois ficar chamando config.put() várias vezes separadamente.

Agora vamos para a parte que você mais vai usar no dia a dia: Android. Aqui é onde o apply realmente brilha.

Você deve estar se perguntando: por que isso funciona tão bem?

A resposta está em um padrão de design chamado Builder. É um padrão de construção onde você vai configurando um objeto passo a passo e no final ele retorna ele mesmo.

Isso permite que você encadeie chamadas, tipo:

objeto.configurar1() \\
    .configurar2() \\
    .configurar3()

O apply faz exatamente isso por baixo dos panos. Ele retorna sempre o objeto ele mesmo, por isso você tem acesso contínuo às funções e propriedades.

Se você abrir o código fonte do apply, vai ver que é uma função genérica que retorna o tipo T, que é o tipo do objeto que você passou. Sempre retorna ele mesmo.

Agora vem a parte importante. Tem coisas que você não deveria fazer com apply, mesmo que funcionem.

Use apply quando:

• Você está inicializando um objeto novo
• Você precisa configurar múltiplas propriedades
• Você quer deixar claro que está construindo/configurando algo
• Você está seguindo o padrão builder

Não use apply quando:

• Você só quer imprimir ou ler valores
• Você quer iterar sobre uma coleção
• Você não está modificando o objeto em si
• Você está fazendo operações que não configuram o objeto

O apply é um recurso simples mas poderoso do Kotlin. Ele resolve a maior parte dos casos onde você precisaria repetir o nome do objeto várias vezes, deixando o código mais elegante e fácil de manter.

No desenvolvimento Android, você vai usar isso constantemente para configurar Views, criar Intents, inicializar objetos complexos. É um dos recursos que separa código Kotlin limpo de código verboso e repetitivo.

A chave é entender que o apply é para configuração de objetos, para aplicar propriedades e valores. Use ele para isso e seu código vai agradecer.

Pratique criar funções e objetos com apply, experimente em diferentes contextos. Com o tempo, vai ficar natural saber quando ele faz sentido e quando o modo tradicional é melhor.

Se você gostou e quer se aprofundar mais em Kotlin e desenvolvimento Android, eu tenho treinamentos completos onde abordo todos os fundamentos da linguagem, desde o básico até as partes mais avançadas, sempre com exemplos práticos.

Curso Android Compose

Curso Android Express (XML)

Clique em um dos links acima.

Aqui está a coisa: no dia a dia de um programador, não basta escrever código bom. Isso é o básico, o esperado. É como ser motorista de Uber e saber dirigir, todo mundo assume que você sabe fazer isso, então não te diferencia em nada.

O que realmente faz diferença, o que realmente te coloca à frente dos outros, é:

• Saber explicar o que você faz para pessoas que não são técnicas
• Conseguir organizar seu tempo quando tem três projetos urgentes batendo na porta
• Aprender rápido quando surge uma tecnologia nova e o prazo é apertado
• Trabalhar bem com pessoas diferentes de você

Essas habilidades, que muita gente chama de “soft” como se fossem menos importantes, são na verdade as mais críticas da sua carreira no longo prazo.

Porque código, vamos ser honestos, qualquer um consegue aprender eventualmente com dedicação e tempo suficiente. Mas comunicação clara, organização eficiente, adaptabilidade genuína? Essas levam anos para desenvolver de verdade e são extremamente escassas no mercado.

Pense comigo por um segundo, quantos programadores excelentes você conhece que:

• Não conseguem explicar suas ideias numa reunião sem entrar em detalhes técnicos que ninguém mais entende?
• Escrevem um código absolutamente impecável, elegante até, mas travam completamente quando precisam apresentar um projeto?
• São tecnicamente brilhantes, resolvem problemas que outros nem tentariam, mas não conseguem trabalhar bem com outras pessoas?

Muitos, muitos mesmo. E todos eles estão deixando oportunidades enormes na mesa sem nem perceber.

Existe um motivo bem claro pelo qual tantos desenvolvedores focam apenas na parte técnica e ignoram todo o resto como se não importasse.

É mais confortável ficar na zona técnica. É mensurável, é tangível:

• Você aprende uma nova linguagem e pode mostrar no LinkedIn
• Resolve um problema complexo e pode compartilhar no GitHub
• Otimiza um algoritmo e vê os números melhorando na tela

São conquistas que você pode provar para si mesmo e para os outros.

Mas como você mede, de forma objetiva, que ficou melhor em se comunicar? Como você comprova num gráfico que aprendeu a gerenciar melhor seu tempo? Como você mostra no seu portfólio que desenvolveu empatia ao trabalhar com o time?

É difícil, extremamente difícil na verdade.

E por ser difícil de medir, por não ter aquele feedback imediato que a gente ama, muita gente simplesmente ignora essas habilidades. Prefere ficar na zona de conforto do código, onde as regras são claras e absolutas, onde o feedback é imediato e binário: o código funciona ou não funciona, compila ou não compila, é preto no branco.

Mas a carreira, a vida profissional real, não é assim de jeito nenhum.

A carreira tem nuances enormes, tem política que você precisa navegar, tem relacionamentos que você precisa cultivar, tem comunicação que acontece o tempo todo mesmo quando você não percebe.

E quem não desenvolve essas habilidades fica estagnado, independente de quão bom seja tecnicamente, independente de quantas linguagens domine ou quantos certificados tenha.

Eu mesmo sempre tive dificuldade com comunicação, e olha que estou falando de algo que me acompanhou por anos, não foi uma coisa que resolvi da noite para o dia.

No começo da minha carreira, eu conseguia resolver problemas complexos de código, conseguia otimizar queries que demoravam minutos para rodar em segundos, conseguia debugar bugs que ninguém mais conseguia encontrar.

Mas travava completamente quando precisava explicar minha solução para outras pessoas não técnicas.

Parecia que as palavras simplesmente não saíam da forma certa, sabe quando você sabe exatamente o que quer dizer mas não consegue articular? Era exatamente isso.

Ou eu era técnico demais e ninguém entendia nada do que eu estava falando, ficava todo mundo com aquela cara de confusão educada, ou eu tentava simplificar demais. Ficava nesse limbo desconfortável entre os dois extremos.

Foi frustrante por muito tempo, muito mesmo.

E eu via colegas com bem menos experiência técnica que eu sendo mais reconhecidos, ganhando promoções, liderando projetos importantes. Simplesmente porque sabiam se comunicar melhor, sabiam vender suas ideias de forma clara, sabiam engajar o time e fazer as pessoas se sentirem parte de algo maior.

Então quais são essas habilidades que fazem tanta diferença assim, que podem mudar completamente a trajetória da sua carreira?

Vou te contar as que mais impactaram minha própria jornada e a jornada de centenas de desenvolvedores que eu formei programador ao longo dos anos.

A boa notícia, e isso é importante você entender bem, é que soft skills não são talento nato que você tem ou não tem.

São habilidades que você pode desenvolver conscientemente, metodicamente, com esforço e prática, exatamente da mesma forma que você aprendeu a programar quando não sabia absolutamente nada.

Uma coisa importante que preciso te dizer com toda sinceridade: você não precisa ser perfeito em todas as soft skills.

Absolutamente ninguém é perfeito em tudo. Eu certamente não sou e nunca vou ser.

Você vai ter áreas onde é naturalmente melhor, onde as coisas fluem sem muito esforço, e vai ter áreas onde você precisa se esforçar bem mais.

Isso é completamente normal e esperado, faz parte de ser humano.

Aqui está a verdade dura que poucos admitem abertamente: depois de um certo nível técnico, que não é nem tão alto assim, todos os programadores realmente bons são mais ou menos equivalentes tecnicamente.

Todos conseguem:

• Resolver os mesmos tipos de problemas se tiverem tempo suficiente
• Aprender as mesmas tecnologias se dedicarem os mesmos esforços
• Entregar código de qualidade razoável quando têm os recursos necessários

O que separa de verdade, o que faz a diferença real entre quem fica estagnado e quem continua crescendo, são as soft skills mesmo.

É o desenvolvedor que consegue influenciar decisões técnicas importantes não só porque tem bons argumentos, mas porque sabe apresentá-los de forma convincente.

É o programador que se torna tech lead não necessariamente porque é o melhor tecnicamente do time, mas porque o time genuinamente confia nele, gosta de trabalhar com ele.

É o que vira arquiteto porque consegue ver o panorama geral do sistema e não só aquele pedaço de código que está na frente dele.

Soft skills são o verdadeiro upgrade da sua carreira no longo prazo, são o multiplicador de força que pega suas habilidades técnicas e amplifica elas para outro nível completamente diferente.

E a melhor parte de tudo isso: você não precisa escolher entre ser excepcionalmente bom tecnicamente e ter boas soft skills. As duas coisas se complementam perfeitamente:

• Quanto melhor você se comunica, mais fácil fica entender problemas complexos
• Quanto melhor você gerencia seu tempo, mais você consegue dedicar a aprender
• Quanto melhor você trabalha em equipe, mais você aprende com pessoas diferentes

Se você chegou até aqui e ainda está lendo, provavelmente está se perguntando por onde começar.

A resposta é bem mais simples do que parece.

Escolha apenas uma soft skill, literalmente só uma mesmo, aquela que você sabe no fundo que está te limitando mais agora.

Não tente trabalhar em todas ao mesmo tempo porque isso não funciona. Você vai ficar sobrecarregado e não vai fazer progresso real em nenhuma delas.

Se comunicação é seu ponto fraco, escreva um post curto sobre algo que você aprendeu recentemente, algum problema que resolveu. Não precisa ser perfeito, não precisa nem ser publicado. O ato de escrever em si já vai começar a te ajudar.

Pequenos passos consistentes, um após o outro, sem pressa mas sem parar.

Consistência humilde que não parece impressionante no dia a dia mas que se acumula de forma exponencial com o tempo.

É assim, exatamente assim mesmo, que você desenvolve soft skills de verdade, não com grandes gestos ou transformações mágicas da noite para o dia.

Desenvolva suas habilidades fora do código com a mesma seriedade que desenvolve suas habilidades técnicas. Elas são o que realmente te fazem ir além, o que abre portas que você nem sabia que existiam.

Se você quer um caminho estruturado para se tornar um desenvolvedor mobile completo, não apenas tecnicamente mas profissionalmente, conheça meus treinamentos de Android e iOS. Além de ensinar toda a parte técnica, eu compartilho experiências reais de carreira, situações que enfrentei, erros que cometi, coisas que aprendi ao longo de 14 anos.

O maior erro de quem começa a programar é querer entender tudo desde o início. É achar que programação funciona como um filme, onde tem começo, meio e fim claramente definidos. Onde cada cena faz sentido na ordem em que aparece. Onde tudo se encaixa perfeitamente desde o primeiro minuto.

Mas programação não é assim.

Programação é muito mais como um quebra-cabeça gigante que alguém jogou no chão. No começo, você olha para aquelas mil peças espalhadas e não faz a menor ideia de como aquilo vai se transformar em algo que faça sentido. Você pega uma peça, tenta encaixar em outra, não funciona. Pega outra peça, também não funciona. E você fica ali, tentando, errando, frustrando-se.

Mas aqui está o segredo que ninguém te conta: esse é o processo. Esse caos inicial não é um sinal de que você não serve para programação. É o caminho natural que todo programador percorre.

Primeiro vem o caos. Depois o sentido. É assim que se aprende a programar de verdade.

Existe uma razão biológica para essa confusão toda. Seu cérebro foi programado, ao longo de milhões de anos de evolução, para buscar padrões e criar significado rapidamente. É um mecanismo de sobrevivência. Quando nossos ancestrais viam uma sombra estranha na floresta, não podiam se dar ao luxo de ficar confusos. Precisavam entender rapidamente se aquilo era uma ameaça ou não.

Então seu cérebro está constantemente tentando encaixar tudo que você está aprendendo em categorias conhecidas, buscando padrões familiares, tentando fazer sentido imediato de cada nova informação.

O problema é que programação não funciona assim.

Quando você está aprendendo a declarar uma variável em Kotlin, por exemplo, seu cérebro não tem nenhuma referência anterior para isso. Não existe nada na sua experiência de vida que se compare diretamente a criar um espaço na memória do computador para guardar um valor que pode mudar.

var idade = 25

Parece simples, certo? Mas seu cérebro está processando várias camadas de abstração simultaneamente. O que é uma variável? Por que var e não outra palavra? O que significa esse sinal de igual? Por que 25 não precisa de aspas mas se fosse um nome precisaria?

São muitas perguntas ao mesmo tempo. E é natural se sentir sobrecarregado.

Mas aqui está o que acontece se você insistir: com o tempo, essas peças do quebra-cabeça começam a se encaixar. Não de uma vez. Não de forma linear. Mas gradualmente, aos poucos, você começa a ver conexões que antes não existiam.

Muita gente abandona a programação porque espera uma progressão linear e previsível. Tipo assim: “hoje eu entendo 10%, amanhã vou entender 15%, depois de amanhã 20%”. Uma escadinha bonitinha subindo.

Mas o aprendizado de programação não funciona em linha reta. Funciona em saltos. Você pode passar dias ou até semanas se sentindo completamente perdido, sem entender nada, achando que não está evoluindo. E de repente, do nada, tudo clica. Você tem um insight. Uma conexão se forma no seu cérebro. E coisas que não faziam o menor sentido há uma semana atrás agora parecem óbvias.

Já passei por isso inúmeras vezes ao longo da minha carreira. Lembro quando estava aprendendo orientação a objetos no começo. Eu lia sobre classes, objetos, herança, polimorfismo. Assistia tutoriais. Fazia exercícios. Mas simplesmente não entrava na minha cabeça. Eu estava seguindo as instruções mecanicamente, mas sem compreender de verdade o porquê daquilo tudo.

Até que um dia, meses depois, eu estava resolvendo um problema real em um projeto. Precisava organizar informações de usuários de forma eficiente. E de repente, clicou. Ah, é por isso que classes existem. É para isso que serve herança. Tudo aquilo que eu tinha estudado de forma fragmentada finalmente fez sentido em conjunto.

E olha, esse padrão se repetiu várias vezes. Cada novo conceito importante em programação passou por essa mesma jornada: confusão inicial, persistência desconfortável, insight súbito, compreensão profunda.

Então a pergunta que fica é: o que você faz enquanto está nessa fase caótica, onde nada parece fazer sentido?

A resposta pode soar frustrante, mas é a verdade: você continua.

• Você aceita que não vai entender tudo agora.
• Você pega pequenas vitórias.
• Você celebra quando um pedaço minúsculo de código funciona, mesmo que não entenda completamente por que funciona.
• Você copia exemplos.

Sim, você leu certo!

No começo, não tem problema copiar código de tutoriais e exemplos. Não estou falando de copiar para entregar trabalhos ou projetos profissionais. Estou falando de copiar para praticar, para ver o código funcionando, para começar a criar familiaridade com a sintaxe.

Com o tempo, você vai parar de copiar e começar a adaptar. Vai pegar um exemplo e mudar uma parte e depois vai combinar dois exemplos diferentes. E eventualmente, vai criar algo completamente do zero.

Mas tudo isso começa aceitando o caos. Aceitando que você não precisa entender tudo perfeitamente desde o primeiro dia.

Vou te dar um exercício prático que ajuda muito nessa fase inicial, se liga.

Escolha um programa simples que você quer criar. Pode ser algo ridiculamente básico, tipo uma calculadora que soma dois números. Não importa se você não sabe exatamente como fazer. Pesquise, copie exemplos, adapte, quebre, conserte, quebre de novo.

O objetivo não é criar algo revolucionário. O objetivo é passar pelo processo completo de fazer algo funcionar. Porque cada vez que você faz isso, mesmo que seja algo simples, você está treinando seu cérebro a pensar como programador.

Aqui está uma verdade inconveniente que poucos professores de programação admitem: você nunca vai entender programação completamente. Nem eu, com 14 anos de carreira, entendo tudo. Não existe um ponto onde você olha para qualquer código e pensa “ah sim, domino isso perfeitamente”.

Sempre vai ter conceitos novos para aprender, situações que vão te desafiar e momentos onde você vai olhar para um problema e pensar “não faço ideia de como resolver isso”.

A diferença é que, com experiência, você fica confortável com essa incerteza e desenvolve confiança de que, mesmo não sabendo a resposta agora, consegue encontrá-la.

Você aprende a pesquisar eficientemente e quebrar problemas complexos em partes menores, testar hipóteses e depurar código.

Essas habilidades são muito mais valiosas do que memorizar sintaxe ou decorar conceitos. Porque tecnologia muda. Linguagens evoluem. Frameworks vêm e vão. Mas a capacidade de resolver problemas, de aprender continuamente, de lidar com a ambiguidade permanece relevante para sempre.

Então quando você está naquela fase caótica inicial, onde nada faz sentido, você não está perdendo tempo. Você está desenvolvendo tolerância à frustração. Está treinando sua mente para lidar com problemas complexos sem ter todas as respostas. Está construindo resiliência.

São essas qualidades, muito mais do que conhecimento técnico específico, que separam programadores que desistem dos que constroem carreiras sólidas.

Aceitar o caos não significa ficar passivo esperando o entendimento cair do céu. Existem coisas práticas que você pode fazer para acelerar sua transição da confusão para a clareza.

Primeiro, e mais importante: programe todo dia. Mesmo que seja só 30 minutos. Mesmo que você não entenda perfeitamente o que está fazendo.

A exposição repetida ao código cria familiaridade e seu cérebro começa a reconhecer padrões mesmo antes de você conseguir explicar racionalmente o que está acontecendo.

É como aprender um idioma. No começo, você não entende as regras gramaticais, mas ouve as pessoas falando e começa a imitar. Com o tempo, antes mesmo de estudar a gramática formalmente, você já está usando as construções corretas intuitivamente.

Programação funciona da mesma forma. Antes de entender completamente os conceitos de orientação a objetos, você já está escrevendo classes. Antes de dominar a teoria de estruturas de dados, você já está usando listas e dicionários. A prática vem antes da compreensão teórica completa. E está tudo bem.

Segundo ponto: construa projetos pequenos e completos. Não fique só fazendo exercícios isolados. Pegue algo simples que você quer criar, mesmo que seja tosco, e leve do início ao fim. Vai ser bagunçado. Vai ter código feio. Vai ter gambiarras. Não importa. Termine!

Porque quando você termina algo, mesmo que imperfeito, você experimenta o ciclo completo de desenvolvimento. E é esse ciclo completo, repetido várias vezes, que transforma confusão em compreensão.

Terceiro: não pule os erros. Quando seu código não funciona, não corra para pedir ajuda imediatamente. Tente entender o erro. Leia a mensagem de erro com atenção, por mais confusa que pareça. Pesquise no Google. Teste hipóteses. Mude uma coisa de cada vez para ver o que acontece.

Esses momentos de luta com erros são onde acontece o aprendizado real. É desconfortável, eu sei. Mas é necessário. Cada erro que você resolve sozinho fortalece suas habilidades de debug e sua confiança como programador.

Deixa eu te contar um segredo sobre programadores sêniores. Aqueles que você vê escrevendo código rapidamente, resolvendo problemas complexos, parecendo saber tudo. A verdade é que eles também passam por momentos de confusão. A diferença é que eles não se assustam mais com isso.

Eu regularmente encontro situações onde não sei a resposta. Onde preciso pesquisar. Onde testo várias abordagens até encontrar a que funciona. A diferença não é que eu sei tudo, é que eu já passei pelo caos tantas vezes que não me desespero mais quando ele aparece.

Sei que eventualmente vou encontrar a solução, que o sentimento de estar perdido é temporário e que cada problema difícil que resolvo me deixa mais preparado para o próximo.

E você vai chegar nesse ponto também. Não amanhã. Não semana que vem. Mas se você persistir, se continuar praticando mesmo quando parece não fazer sentido, você vai olhar para trás daqui alguns meses e se surpreender com o quanto evoluiu.

Vai pegar código que você escreveu no começo e pensar “nossa, como eu não entendia isso”. E vai dar risada disso!

Se você está na fase caótica do aprendizado de programação agora, aqui está o que você precisa fazer. Não é complicado, mas requer compromisso.

Escolha uma linguagem. Não importa qual. Se você quer desenvolver apps mobile, escolha Kotlin para Android ou Swift para iOS, se quer fazer web, escolha JavaScript, se quer automação, escolha Python.

O importante é escolher uma e se comprometer.

Defina um projeto simples. Muito simples mesmo. Tipo: um app que mostra uma lista de tarefas, ou um site que exibe informações sobre você, ou um script que organiza arquivos no seu computador. Algo pequeno que você possa completar em alguns dias ou semanas.

Programe todo dia. Nem que seja meia hora.

Abra o editor de código, escreva algumas linhas, quebre coisas, conserte e celebre pequenas vitórias.

Aceite que vai ser confuso e que você não vai entender tudo. Que vai ter dias frustrantes, mas continue mesmo assim ok?

Porque do outro lado desse caos está uma das carreiras mais recompensadoras que existem no planeta.

E lembre-se: todo programador que você admira, todo desenvolvedor que cria aplicativos incríveis, todo sênior que parece saber tudo, todos eles começaram exatamente onde você está agora. Confusos, inseguros, sem entender direito o que estavam fazendo.

A única diferença entre eles e você é que eles não desistiram durante o caos. Eles aceitaram que o caos faz parte do processo. E continuaram.

Você também pode fazer isso. O caos é apenas o começo.

Se você quer um caminho estruturado para se tornar um desenvolvedor mobile, conheça meus treinamentos de Android e iOS. Vou te guiar do zero ao profissional com a progressão certa para transformar confusão em clareza.

O segredo que você precisa entender é este: comece com o que você tem agora.

Não estou falando para sair criando coisas sem pensar. Estou falando que a espera pelo “momento perfeito” é uma ilusão. Esse momento não existe. E quanto mais você espera, mais se afasta da possibilidade de realmente fazer isso acontecer na sua vida.

Pense bem. Quantas pessoas você conhece que ficaram anos dizendo que fariam algo importante “quando chegasse a hora”? E quantas delas realmente fizeram? A estatística é assustadora. A maioria nunca faz.

Porque a vida não funciona assim. A vida não envia um convite especial avisando que agora é a hora certa. Nem o universo conspira para que todas as circunstâncias se alinhem perfeitamente para você começar.

O que realmente acontece é que você cria condições mínimas aceitáveis e começa. Do resto, você vai aprendendo no caminho.

Aqui está outra verdade que muita gente ignora: programação é um processo de longo prazo. Você vai errar. Muito. Vai aprender com esses erros, vai errar novamente e vai melhorar.

Isso não é um problema. Isso é a normalidade.

Se você espera que aprender programação seja como assistir um filme, onde você quer que tudo faça sentido perfeitamente no início, você vai ficar decepcionado. A programação é muito mais como escalar uma montanha. Tem trechos íngremes, tem momentos onde você sente que parou de evoluir, tem curvas inesperadas. Mas no fim, se você continuar caminhando, chega no topo.

A diferença entre quem chega no topo e quem desiste meio do caminho não é talento. Muitas vezes é apenas consistência e aceitação de que a jornada tem altos e baixos.

Quando você entende isso, aceita errar como parte do processo, fica muito mais fácil começar sem ficar paralisado esperando perfeição. Porque você já sabe que perfeição no início não existe mesmo.

Agora deixa eu provocar você com uma pergunta importante: você sabe o que realmente significa ser um programador profissional?

Muita gente acha que é só digitar código. Que programador é a pessoa que fica a noite inteira em frente a um computador escrevendo linhas e linhas de código.

Mas a verdade é muito mais interessante do que isso.

Ser um programador profissional é resolver problemas que parecem impossíveis à primeira vista. É criar coisas novas que não existiam antes. É trabalhar com pessoas de diferentes partes do mundo, colaborando em equipes incríveis. É ganhar bem por trabalho qualificado. E acima de tudo, é construir liberdade na sua vida profissional.

Mas, e aqui vem o custo, tudo isso tem um preço. Não um preço em dinheiro. Um preço em dedicação, constância e vontade de continuar mesmo quando as coisas ficam difíceis.

Muita gente quer os benefícios dessa carreira mas não quer pagar o preço. Quer ganhar bem mas não quer estudar. Quer liberdade profissional mas não quer se comprometer com a evolução constante. Quer criar coisas inovadoras mas quer que tudo seja fácil e sem sofrimento.

Isso não é como funciona. Nunca foi.

A verdade é que todo programador experiente que você vê hoje, aquele que conseguiu construir uma carreira sólida e está ganhando bem, passou pelo que você está passando agora. Ele também começou do zero. Também se sentiu perdido. Também teve dúvidas se tinha capacidade.

A única diferença é que ele começou. E continuou.

Deixa eu ser direto. O diferencial real entre quem consegue e quem não consegue em programação não é talento especial. Não é ter nascido “com o dom”. Não é nenhuma qualidade mágica.

O diferencial é simples: é ter começado. E continuado.

Porque quando você começa, mesmo que de forma imperfeita, você entra em movimento. E movimento gera aprendizado. Aprendizado gera experiência. Experiência gera confiança. Confiança gera mais movimento.

É um ciclo virtuoso. Mas tudo começa com um primeiro passo.

Todos os grandes programadores que você conhece fizeram esse primeiro passo. Talvez não foi fácil. Talvez tiveram medo. Talvez quiseram desistir no meio do caminho. Mas começaram apesar disso.

E é exatamente isso que está te separando agora do programador que você pode se tornar. Não sua capacidade. Sua disposição de começar com o que você tem, onde você está, agora mesmo.

Então aqui está meu desafio para você. Não é um desafio complicado. Mas é real.

Hoje, ainda nesse momento em que terminou de ler esse artigo, escolha algo pequeno. Muito pequeno mesmo. Algo que você possa fazer em 30 minutos.

Pode ser:

Assistir um tutorial sobre a linguagem de programação que você quer aprender. Só um, não precisa de mais. E depois tente replicar o que viu.

Criar uma conta em uma plataforma de aprendizado online e fazer as primeiras aulas de um curso.

Se você já tem algum conhecimento, pegar um problema simples e tentar resolver usando código.

Documentar qual é seu objetivo real com programação. Por que você realmente quer aprender? O que você quer criar? Onde quer trabalhar? Quanto quer ganhar? Seja específico.

É isso. Algo pequeno. Mas que quebra a inércia.

Porque sabe qual é o segredo de tudo? Começar é a parte mais difícil. Depois que você começou uma vez, começar novamente fica mais fácil. E assim você cria momentum.

Momentum é o que transforma aspirações em realidade.

Você provavelmente conhece a sensação de estar parado esperando a vida melhorar por mágica. Esperando que as circunstâncias se alinhem. Esperando pela oportunidade perfeita.

Aqui está a verdade que ninguém gosta de ouvir: essa espera nunca termina.

Porque a vida não funciona daquele jeito. Não é assim que mudanças significativas acontecem. Mudanças significativas acontecem quando você decide que está cansado de esperar e começa a agir.

Mesmo que seja um passo pequeno. Mesmo que você se sinta desconfortável. Mesmo que a voz dentro de sua cabeça diga que você não está pronto.

Faça mesmo assim.

Comece hoje, com o que você tem. O resto vem com o tempo. A experiência vem com a prática. A confiança vem do resultado do seu trabalho.

Programação é para quem começa. E realmente, quem continua sempre é capaz de realizar.

Você tem tudo que precisa para começar agora mesmo.

Se você está pronto para começar seu caminho em desenvolvimento mobile, com uma estratégia clara e estruturada do zero ao profissional, conheça meus treinamentos de Android e iOS. O momento certo é agora. Não espere mais.