---
title: "Globant São Paulo: Vagas de IoT Edge e Embarcados 2026"
url: "https://ziglang.com.br/empresas/globant/"
markdown_url: "https://ziglang.com.br/empresas/globant.MD"
description: "Vagas da Globant em São Paulo: IoT Edge Engineer com C++, Rust, Linux, RTOS e CMake. Stack, perfil sênior híbrido e como se preparar com Zig."
date: "2026-07-29"
author: ""
---

# Globant São Paulo: Vagas de IoT Edge e Embarcados 2026

Vagas da Globant em São Paulo: IoT Edge Engineer com C++, Rust, Linux, RTOS e CMake. Stack, perfil sênior híbrido e como se preparar com Zig.


A Globant aparece no radar brasileiro de **programação de sistemas embarcados e IoT Edge** com a posição de **IoT Edge Engineer** em **São Paulo (SP)**, em modelo **híbrido**, pedindo domínio de **C++, Rust, Linux, RTOS, CMake e Gitflow**. A resposta direta para quem avalia a empresa é: o perfil mais aderente é o de engenharia sênior capaz de arquitetar e entregar software de borda e de dispositivo com performance previsível, integração contínua e disciplina de *code review* em ambiente de consultoria/produto para clientes. As posições abrem e fecham com frequência; confira sempre o anúncio oficial no portal de carreiras e acompanhe o nosso [hub de vagas de tecnologia](/vagas/).

Esta página reúne o que o nosso catálogo capturou sobre a Globant, a stack esperada, o contexto de São Paulo no mapa de *edge* e embarcados, como montar um portfólio útil e onde [Zig](/tutoriais/o-que-e-zig/) fortalece fundamentos de memória, interoperabilidade com C/C++ e *builds* determinísticos **sem substituir** C++, Rust, Linux ou RTOS no anúncio. Não há evidência pública de que a Globant use Zig em produção nessas equipes — a candidatura deve priorizar exatamente o que a vaga lista.

## Vagas da Globant: o perfil de IoT Edge capturado

O nosso radar registrou a posição de **IoT Edge Engineer - BR (São Paulo)**, com:

- **localização** em São Paulo, São Paulo;
- **modelo híbrido** (não 100% remoto);
- **senioridade** de nível sênior / *individual contributor*;
- stack explícita: **C++**, **Rust**, **Python**, **Linux**, **RTOS**, **CMake**, **Gitflow** e práticas ágeis;
- canal de candidatura via portal de carreiras da Globant (SuccessFactors / *career-legacy.globant.com*).

Esse conjunto descreve o tipo de vaga em que o software “mora” no *gateway*, no controlador de borda, no módulo de telemetria ou no *runtime* de dispositivo — não em um monólito web genérico. O dia a dia tende a envolver arquitetura de *edge*, otimização de CPU/memória/energia, integração com Linux e RTOS, *toolchains* com CMake, fluxos de *branch* Gitflow e correção de defeitos que só aparecem sob carga, *timeout* de rede ou restrição de recursos.

Mesmo quando o anúncio específico some do ar (vagas de consultoria e de *studios* rotacionam rápido), o **perfil evergreen** permanece: a Globant e empresas semelhantes contratam de forma cíclica engenheiros capazes de entregar **IoT Edge** com C++/Rust em Linux/RTOS. Use o [guia de vagas de sistemas embarcados](/carreira/vagas-zig-sistemas-embarcados/) para comparar com outras empresas do eixo SP–Campinas–Sorocaba, como [Qualcomm](/empresas/qualcomm/), [Tractian](/empresas/tractian/), [Flex](/empresas/flex/), [Toradex](/empresas/toradex/) e [Bosch Brasil](/empresas/bosch-brasil/).

## O que a Globant faz e por que isso importa para sistemas

A Globant é uma empresa global de **transformação digital e engenharia de software**, com origem na Argentina (2003) e presença forte no Brasil — em especial em **São Paulo**. Diferente de um *OEM* de *hardware* que fabrica um único produto de marca própria, a Globant costuma atuar em **studios e contas de clientes**: desenha, implementa e opera soluções de software, *design*, dados e, no recorte que interessa a este site, **sistemas embarcados e IoT Edge**.

Para o profissional de sistemas, o ponto relevante é a interseção entre:

- **edge computing** (processar perto do sensor/atuador, não só na nuvem);
- **restrições de recurso** (CPU, RAM, *flash*, energia, *thermal*);
- **Linux embarcado ou de *gateway*** + **RTOS** no mesmo produto ou na mesma linha;
- **C++ e Rust** como linguagens de desempenho e de segurança de memória no *edge*;
- **entrega em conta de cliente** (escopo, *milestones*, *code review*, *CI*, documentação).

Uma *race condition*, um *deadlock* em *mutex* de RTOS ou um *leak* de memória em um *daemon* de *gateway* não é um bug cosmético: pode silenciar telemetria de fábrica, travar um *edge node* em campo ou gerar *rollback* caro em *release* de cliente. Por isso, vagas de IoT Edge na Globant se encaixam no mesmo funil de quem estuda [Zig para embedded](/carreira/zig-para-embedded-carreira/), [sistemas embarcados em Zig](/tutoriais/zig-embedded-systems/) e [IoT com Zig](/artigos/zig-embarcados-iot/) — mesmo quando o anúncio pede C++/Rust e RTOS, não Zig.

## São Paulo e o mapa de edge / embarcados

São Paulo concentra times de produto, consultoria e *R&D* de software com clientes industriais, *retail*, *mobility* e *telecom*. No nosso mapa de empresas, o contraste ajuda a orientar carreira:

| Polo | Empresa (perfil no site) | Ênfase típica |
|---|---|---|
| **São Paulo** | **Globant** | IoT Edge sênior (C++/Rust, Linux, RTOS, CMake) |
| **São Paulo** | [Qualcomm](/empresas/qualcomm/) | Semicondutores, Edge-AI, Linux/Yocto |
| **São Paulo** | [Tractian](/empresas/tractian/) | Firmware IoT industrial (freeRTOS, ESP, STM) |
| **São Paulo** | [Accenture](/empresas/accenture/) | Consultoria e entrega de software em escala |
| **Sorocaba** | [Flex](/empresas/flex/), [Nextpower](/empresas/nextpower/) | EMS e energia / *trackers* com C/RTOS |
| **Campinas** | [Bosch Brasil](/empresas/bosch-brasil/), [Toradex](/empresas/toradex/) | Automotivo / SoM e Linux embarcado |

Para quem gosta de programação de sistemas, a Globant puxa o lado **entrega de *edge* em conta de cliente** com stack moderna (C++ **e** Rust), enquanto Tractian e Nextpower puxam o lado **produto próprio de *hardware***. O modelo **híbrido em São Paulo** favorece *lab* de *hardware* quando a conta exige, *pair programming* e proximidade com *stakeholders* — algo que vagas 100% remotas de *backend* raramente oferecem da mesma forma. Acompanhe o [hub de vagas](/vagas/) e o panorama de [Zig no mercado de trabalho](/carreira/zig-no-mercado-de-trabalho/) para encaixar essa oportunidade na sua estratégia.

## Stack técnica: o que estudar para a entrevista

### C++ no *edge* e no *firmware host*

Revise *RAII*, *move semantics*, *lifetime*, *undefined behavior*, *atomics*, *const-correctness* e o custo de alocação em caminhos quentes. Em *edge*, “C++ moderno” significa também:

- *APIs* estáveis entre *drivers*, *middleware* e aplicação;
- tratamento explícito de erros de *I/O* e de sensor (sem engolir exceções em *ISR*);
- containers e *allocators* previsíveis sob pressão de memória;
- disciplina de *logging* e de *tracing* que não destrua *timing*.

Prepare exemplos em que você isolou *data race*, *use-after-free*, *priority inversion* ou um *bug* intermitente com *sanitizers*, *trace* ou *probe*.

### Rust no *edge*: segurança de memória com performance

O anúncio cita **Rust** ao lado de C++ — sinal de times abertos a *rewrites* parciais, *tooling* ou módulos novos em Rust. Domine:

- *ownership*, *borrowing* e *lifetimes* sem “brigar” com o *borrow checker* em público;
- `no_std` vs `std` e quando cada um faz sentido em *edge*;
- *FFI* com C/C++ (a ponte real de projetos legados);
- *async* embutido com cuidado (ou *threads* + filas, se o produto for RTOS-centrado);
- testes, *fuzzing* e *CI* para regressões de memória e de protocolo.

Na entrevista, explique **por que** um módulo foi (ou seria) Rust e não C++: superfície de *unsafe*, *ABI*, maturidade de *crates*, tempo de *build* e habilidade do time.

### Linux e RTOS convivendo

Linux aparece como *runtime* de *gateways*, *hosts* de aplicação e ambiente de desenvolvimento; RTOS aparece no MCU ou no *firmware* de tempo real. Estude:

- tarefas, prioridades, filas, *mutex* e *priority inversion* em RTOS;
- *ISR* curta + *deferred work*;
- *watchdog*, estados degradados e *fail-safe*;
- no Linux: *systemd*, permissões, *networking*, *cgroups* básicos, *strace*/*perf*;
- IPC entre processos Linux e *firmware* (serial, *sockets*, *shared memory*, *MQTT*/*DDS* conceitual).

“Tempo real” em IoT Edge costuma significar **previsibilidade operacional**, não necessariamente *hard real-time* aeroespacial. Saiba medir latência de ponta a ponta do sensor ao *payload* publicado.

### CMake e Gitflow: higiene de *release*

**CMake** e **Gitflow** no anúncio são filtros de senioridade de entrega. Espere conversas sobre:

- *targets*, *toolchains* de *cross-compile*, *presets* e *out-of-tree builds*;
- *flags* por *profile* (debug/release/size);
- *branches* `main`/`develop`/`feature`/`release`/`hotfix` e *code review*;
- *tags*, *changelogs* e *bisect* em regressões;
- *CI* que compila para o *target* real (não só para *x86_64* do *laptop*).

Quem só conhece “abrir o *IDE* e clicar Build” costuma tropeçar aqui. Mostre repositórios com *pipeline* mínima e instruções de reprodução.

### Python como alavanca de bancada

Python no *edge* raramente é o *runtime* do dispositivo crítico — é a cola de **teste, *flash*, validação, *parsers* e automação**. Mostre *scripts* que:

- exercitam um protocolo serial ou *socket*;
- geram *fixtures* e *golden files*;
- automatizam *smoke tests* pós-*flash*;
- coletam métricas de latência e de memória.

## Como o Zig pode diferenciar seu currículo

Não há evidência pública de uso de Zig nas equipes de IoT Edge da Globant. A linguagem **não substitui** C++, Rust, Linux, RTOS ou CMake. O valor está em servir como laboratório moderno de programação de sistemas.

### Memória explícita e erros visíveis

Zig força decisões de *allocator*, *ownership* e caminhos de erro. Isso treina a mesma disciplina de um *buffer* de telemetria ou de um *parser* de *frame* industrial. Estude [gerenciamento de memória em Zig](/tutoriais/gerenciamento-de-memoria-zig/), [segurança de memória](/tutoriais/zig-seguranca-memoria/) e [tratamento de erros](/tutoriais/tratamento-de-erros-em-zig/) com projetos pequenos e testáveis.

### Interoperabilidade com C e a ponte com C++/Rust

A [interoperabilidade entre Zig e C](/tutoriais/zig-c-interoperabilidade/) permite escrever testes, *fuzzers* ou ferramentas de diagnóstico ao redor de *drivers* e *parsers*. Em bases de cliente, a estratégia incremental (ferramenta ao redor, não reescrita total) costuma ser mais crível do que “vamos migrar o *firmware* para X”. O guia de [transição de C para Zig](/carreira/transicao-c-para-zig/) e o de [transição de Rust para Zig](/carreira/transicao-rust-para-zig/) ajudam a mapear o que você já sabe.

### *Cross-compilation* e *builds* determinísticos

Pratique [cross-compilation](/artigos/zig-cross-compilation-guia/) e o [Zig Build System](/tutoriais/zig-build-system/). Em entrevista, conecte o aprendizado ao problema real: *toolchains* reproduzíveis, *targets* ARM, *flags* de otimização e artefatos versionados — o mesmo músculo mental de CMake + *sysroot* + *flash* em *lab*.

Use o material de [sistemas embarcados](/tutoriais/zig-embedded-systems/) e de [IoT](/artigos/zig-embarcados-iot/) como **treino de vocabulário**, não como pretensão de que a vaga pede Zig.

## Projeto de portfólio recomendado

Um portfólio forte para essa vaga é um **nó de IoT Edge simplificado** — *gateway* ou *edge agent* que sobrevive a falha de rede e de sensor.

O projeto pode incluir:

- processo Linux (C++ e/ou Rust) consumindo sensores via serial/UART, *socket* ou *MQTT*;
- módulo opcional em MCU com RTOS amostrando e enviando *frames* para o *host*;
- filas offline, *backoff* e *idempotência* de telemetria;
- *fail-safe* documentado (sensor inválido → estado seguro / alarme);
- *CMake* (e, se quiser, um alvo Zig para *tooling* de teste/*fuzzer*);
- *Gitflow* real no histórico do repositório (não só *commits* soltos em `main`);
- testes unitários do *parser*/estado + *script* Python de bancada;
- README com diagrama de processos/tarefas, ameaças (*brownout*, *watchdog*, partição de rede) e como reproduzir.

Se puder, mostre métricas: uso de RAM, latência p95 do caminho sensor→publicação, taxa de perda sob *stress*, tempo de *reconnect*. O importante é evidência de engenharia de *edge*, não *demo* de *blink* ou de *CRUD*.

## Como preparar currículo e entrevista

Adapte o [currículo de desenvolvedor de sistemas](/carreira/curriculo-desenvolvedor-zig/) ao vocabulário do anúncio. Priorize:

- C++ e/ou Rust com contexto de *edge* ou embarcado;
- Linux (de *gateway* ou de *host* industrial);
- RTOS (tarefas, filas, *ISR*, *debugging*);
- CMake + Gitflow (fluxo de *build* e de *release*);
- resultados mensuráveis (latência, estabilidade, tempo de *bring-up*, redução de incidentes);
- inglês técnico (anúncios e documentação misturam PT/EN; a Globant é empresa global).

Prepare histórias STAR sobre defeitos difíceis: sintoma em *lab* ou em conta de cliente, hipótese, ferramenta (*sanitizer*, *trace*, *logic analyzer*, *probe*), causa raiz, correção e regressão. Para senioridade em consultoria, discuta também *code review*, critérios de *Definition of Done* de *firmware*, comunicação com *hardware*/*QA* e negociação de escopo. Consulte as [perguntas de entrevista para sistemas embarcados](/entrevistas/perguntas-sistemas-embarcados-zig/) e o panorama de [salários em programação de sistemas](/carreira/salario-programador-zig/).

## Globant ou outras empresas de sistemas no Brasil?

A escolha depende do domínio e do formato de trabalho que você quer. Compare:

| Empresa | Contexto principal | Perfil técnico típico |
|---|---|---|
| **Globant** | Consultoria / *studios* + IoT Edge (SP) | C++, Rust, Linux, RTOS, CMake, híbrido |
| **Tractian** | Produto IoT industrial próprio | freeRTOS, ESP-IDF, STM, telemetria |
| **Qualcomm** | Semicondutores e Edge-AI (SP) | C/C++, Linux/Yocto, Python |
| **Flex** | Manufatura eletrônica (Sorocaba) | C/C++/Rust, testes, engenharia de produto |
| **Nextpower** | Energia / *trackers* (Sorocaba) | C, RTOS, Linux, Make, JTAG |
| **Toradex** | Módulos e Linux embarcado | Yocto, *device trees*, sistemas industriais |
| **Bosch Brasil** | Automotivo / industrial (Campinas) | C/C++, processos, qualidade |

Leia os perfis da [Tractian](/empresas/tractian/), [Qualcomm](/empresas/qualcomm/), [Flex](/empresas/flex/), [Nextpower](/empresas/nextpower/), [Toradex](/empresas/toradex/) e [Bosch Brasil](/empresas/bosch-brasil/) para calibrar stack e ambiente. A Globant é especialmente interessante para quem quer **IoT Edge com C++ e Rust em São Paulo**, experiência de entrega em conta de cliente e senioridade em Linux/RTOS — desde que a preparação respeite a stack do anúncio e a realidade de *edge*.

## Perguntas frequentes

### A Globant tem vagas de IoT Edge em São Paulo?

Sim. O nosso radar capturou a posição de **IoT Edge Engineer** em São Paulo (SP), com stack C++, Rust, Linux, RTOS, CMake e Gitflow, em modelo híbrido. A disponibilidade muda: confirme no portal oficial de carreiras da Globant e acompanhe o [hub de vagas](/vagas/).

### Quais tecnologias aparecem nessas vagas?

Os registros recentes citam **C++**, **Rust**, **Python**, **Linux**, **RTOS**, **CMake**, **Gitflow** e práticas ágeis. Em torno disso, espere conversas sobre arquitetura de *edge*, performance sob restrição de recursos, *toolchains*, *CI* e estabilidade em campo ou em *lab*.

### O trabalho é remoto, híbrido ou presencial?

O anúncio capturado aponta modelo **híbrido em São Paulo**. Sempre confirme regime, dias em escritório/*lab*, equipamentos e política atual no texto oficial da vaga — contas de cliente e *studios* mudam o arranjo com frequência.

### Preciso ter trabalhado em consultoria para me candidatar?

Não necessariamente. Ajuda demonstrar entrega sob escopo e *deadline*, mas o filtro técnico costuma ser **C++/Rust + Linux/RTOS em contexto de *edge* ou embarcado**. Se você vem de produto próprio, mostre *releases*, *incidentes* e *code review*; se vem de *firmware* puro, mostre também comunicação com *stakeholders* e *CI*.

### A Globant usa Zig?

Não há evidência pública de uso de Zig nessas equipes de IoT Edge. Use Zig como laboratório de memória, interoperabilidade com C, erros explícitos e *builds* reproduzíveis. Na candidatura, priorize a stack do anúncio (C++, Rust, Linux, RTOS, CMake).

### Onde faço a candidatura?

Use o portal de carreiras da Globant (SuccessFactors / *career-legacy.globant.com* e canais atuais em [globant.com](https://www.globant.com)) e o [LinkedIn da empresa](https://www.linkedin.com/company/globant/). Pesquise por “IoT”, “Edge”, “Embedded”, “C++”, “Rust” e “RTOS”. Leia o anúncio completo, adapte o currículo aos requisitos e evite intermediários que peçam documentos sensíveis fora do processo oficial.

## Próximos passos na carreira de sistemas

Se você está montando um plano de transição para esse tipo de vaga:

1. consolide C++ e/ou Rust com um projeto de *edge* que tenha *fail-safe* e filas offline;
2. pratique Linux de *gateway* + noções sólidas de RTOS (mesmo em MCU barato);
3. mantenha *builds* reproduzíveis com CMake (e, se quiser, Zig como *tooling* paralelo);
4. use [Zig](/tutoriais/o-que-e-zig/) para treinar fundamentos, não para substituir a stack da vaga;
5. acompanhe o [mercado de trabalho de sistemas](/carreira/zig-no-mercado-de-trabalho/), o [hub de empresas](/empresas/) e o [guia de vagas embarcadas](/carreira/vagas-zig-sistemas-embarcados/);
6. candidate-se quando o portfólio e as histórias de entrevista estiverem alinhados ao anúncio.

A Globant representa uma porta concreta no **polo de São Paulo** para quem quer **IoT Edge sênior com C++ e Rust**, Linux, RTOS e entrega profissional em escala de consultoria. Prepare-se para o metal, para o *edge* e para o ritmo de conta de cliente; o restante da stack de carreira em sistemas no Brasil se conecta a partir daí.
