Work

Offers and case studies for teams shipping connected products under real delivery pressure.

G2Labs is most useful when the hard part is not a single module, but the boundary between the device, the software around it, and the need to make it dependable enough to ship.

Discuss a project Read case studies

Packages

Two easy ways to start

Fixed scope · 2–3 weeks

Nordic / Zephyr firmware audit

Find out what is wrong with your firmware before your customers do.

A structured review of the code and configuration of an nRF52 or nRF54 device built on Zephyr or the nRF Connect SDK.

Security: key handling, DTLS / TLS, MCUboot setup, image signing, and rollback
Architecture and code quality: threads, memory, drivers, Devicetree and Kconfig
Field updates: the OTA path and the risk of bricking devices in the field

A written report with findings ranked by severity and concrete recommendations, plus a one-hour walkthrough with your team.

From €1,900 net

Tell me about your project

Monthly · 10 or 20 hours

Zephyr / nRF expert on retainer

A senior embedded engineer on your team without a senior hire.

A fixed block of hours each month for a team that already has its own developers and needs a second pair of experienced eyes.

Code review and architecture consultations
Hard problems: Thread, BLE, CoAP, bootloader, and low-power behavior
Helping developers who are new to Zephyr get productive faster

Asynchronous contact over Slack or email and one call a week. Unused hours do not roll over.

From €800 net / month

Tell me about your project

Send a short note on the product and the problem. I reply within two business days with a proposed scope.

Offer 01

Firmware delivery sprint

Fix, stabilize, or ship the firmware slice blocking the product: board bring-up, Zephyr and other RTOS work, BLE and Thread behavior, protocol code, MCUboot field updates, or code that has become hard to change safely.

Best when a product team needs reliable device behavior now, not another broad assessment that leaves implementation untouched.

Implementation in C or C++ across bare-metal and RTOS-based targets, with Nordic nRF54 / nRF52 and Zephyr as the current home ground
Debugging, integration, and focused handover notes for the owning team
A short plan around the riskiest technical decisions instead of broad discovery theater

Offer 02

Connected product integration

Build the part where the device becomes a product: secure CoAP or MQTT flows, payloads and APIs, provisioning and update paths, backend touchpoints, and the tools operators actually use.

Best when firmware exists, but the product still breaks down once data leaves the device.

Device-to-backend or device-to-app interface definition grounded in real constraints, including transport security (DTLS / TLS) and key handling
Utility software, integration code, or supporting product tooling around the embedded core
Practical alignment on where responsibilities sit between firmware, backend, and UI layers

Offer 03

MVP and delivery acceleration

Move an embedded or connected-product MVP from uncertain prototype work toward a buildable product path with hands-on implementation, sharp scope, and explicit technical decisions.

Best when a small team has to ship across hardware and software without waiting until later to discover the risky boundary.

Architecture and implementation help on the slice that currently blocks progress
Agentic, AI-assisted implementation, documentation, and internal tooling where it genuinely shortens the loop, with human review kept in charge
A realistic path from prototype behavior to something a team can keep building on

Engagement profile

Most useful where delivery risk lives between device logic, connectivity, and the software stack around the product.

Established companies: embedded execution, technical leadership on implementation slices, and integration-heavy product work.

Startups and MVPs: early architecture and practical delivery when a connected product cannot wait for separate specialist tracks.

Experience timeline

A direct overview of the companies, periods, and delivery areas behind the work.

2025-present

MicrOS Project

Creator & Maintainer

Designed and launched MicrOS as a lightweight open-source real-time operating system for microcontrollers and small systems, built around clarity, public learning, and practical experimentation.

MIT-licensed project with public docs, contribution flow, and governance pages
Build flow centered on CMake, Ninja, QEMU, and board-oriented configuration
Growing toward scheduler, drivers, multitasking demos, and broader ARM Cortex-M, POSIX, and RISC-V support

2023-present

Sigma Software Group

Senior Software Developer

Client-facing embedded product delivery for connected low-power devices, from firmware to end-to-end architecture. Project details are under NDA.

Firmware for low-power wireless devices on a modern RTOS
Secure device-to-service communication
End-to-end architecture work with an agentic, AI-assisted development workflow

2018-present

G2Labs Grzegorz Grzęda

Independent Business Owner

Runs G2Labs as an independent engineering practice delivering embedded systems, IoT solutions, utility software, and software planning for client work.

Complete embedded software solutions for client products including medical robotics work
Software project management, planning, and practical delivery support
Embedded, desktop, and utility software in C, C++, Qt, and adjacent tooling

2021-2023

Baracoda Group (Alsoft)

Senior Embedded Software Engineer

Connected embedded product delivery for Baracoda through Alsoft, a Baracoda company, focused on dependable device behavior, Wi-Fi connectivity, and safe field updates.

ESP32 firmware for an intelligent weight scale with Wi-Fi connectivity
FOTA update paths tied to real device behavior in the field
Embedded delivery tied to broader product behavior and field reliability

2020-2021

Softwarely

Senior Embedded Software Engineer, then Team Leader

Started as a senior embedded engineer and moved into leading the embedded team while delivering BLE Mesh sensoring solutions.

Embedded team leadership with hands-on technical ownership
Delivery ownership for BLE Mesh sensoring work
Wireless and sensor-oriented embedded implementation

2020-2021

SeaChange Poland

Client Legacy Embedded Engineer, then Client Roku Developer

Developed client software for legacy Motorola set-top-box platforms, then Roku client applications for a production media platform serving large subscriber bases.

Client application development in C for legacy embedded platforms
Roku client software in BrightScript under live product expectations
Python utility software around product delivery

2019-2020

DisplayLink

Senior Embedded Development Engineer

Senior embedded development inside an established specialist product organization.

Senior embedded development role
Experience inside an established embedded engineering organization
Worked in a specialist product-development environment

2018-2019

M2MTeam Sp. z o.o.

Senior Software Developer

Led teams and delivered software solutions for the medical field, including medical robotics and sensing-related systems.

Custom embedded solutions for medical robotics
Environment sensing and data collection through a web application
Human and equipment indoor localization work

2017-2018

JM-TRONIK

Software Developer

Developed embedded software and related support systems for smart-grid solutions.

Low-level embedded drivers in an RT environment
Backend server work for user web accessibility
Qt-based utility software around the embedded product

2017-2017

M2MTeam Sp. z o.o.

Embedded Software Developer

Worked on embedded environmental measurement solutions with BLE and LoRa connectivity.

Architectural work for BLE temperature and humidity sensors
Custom communication protocol for low-throughput links
Custom bootloader and OTAU solutions

2015-2017

Military University of Technology

Scientific Researcher

Conducted lab classes and research around picosecond-precision time measurements, FPGA systems, and measurement-device software.

Teaching materials for integrated-circuit lab classes
GUI software for dedicated time-measurement devices
Precise time-measurement sensors implemented in Xilinx FPGAs

2015-2015

SiDLY sp. z o.o.

Embedded Software Developer

Worked on an embedded BLE platform with communication, RTOS-oriented refactoring, and production programming support.

BLE communication link between host and onboard MCU
Software architecture refactoring for RTOS adoption
Custom bootloader and production-bench software support

2011-2011

E3 Technology sp. z o. o.

Embedded Measurement Systems Designer

Designed and updated software and PCB designs for embedded measurement systems using analog and mixed-signal acquisition paths.

Embedded measurement-system design
Software and PCB updates in the same engineering scope
Analog and mixed-signal measurement channels with basic DSP

Start here

The best first message is a concrete bottleneck: what is stuck, what hardware or stack is involved, and what has to ship next.

Send a project brief

Case studies

These are the kinds of situations where G2Labs is most useful: product boundaries, embedded delivery pressure, and software around the device that still has to make sense.

Sigma Software Group / 2023-present

Secure low-power wireless device, from radio to service

Context: Client-facing connected-device delivery where low-power mesh networking, secure transport, and the service behind the device had to be designed together. Client and product details are under NDA.

Network behavior, transport security, and the end-to-end architecture all affect each other, so none of them could be designed in isolation or handed between separate teams.

low-power wirelessmesh networkingdevice securityunder NDA

What I owned: Owned firmware and end-to-end architecture work, including the secured communication path between the device and the backend.

Firmware for a low-power wireless device on a modern RTOS
Secured device-to-service communication
End-to-end architecture spanning device, network, and service, delivered with an agentic, AI-assisted workflow under human review

A connected-device architecture where radio, security, and service decisions are made together instead of being reconciled late.

Relevant for products built on low-power mesh networking
Shows ownership of transport security, not only application firmware
Useful when teams need one engineer who keeps the device, the network, and the service in the same design

Baracoda / 2022-2023

Connected weighing product with ESP32, Wi-Fi, and FOTA

Context: A connected product where device behavior, network behavior, and safe field updates all had to hold together in one shipped system.

The product surface extended beyond the device itself, so wireless architecture and field-ready update behavior had to be dependable from the start.

ESP32Wi-FiFOTA updatesembedded firmware

What I owned: Built firmware around ESP32 and Wi-Fi connectivity, with direct responsibility for update behavior and product-side reliability at the device boundary.

Built firmware for an intelligent weight scale around ESP32 and Wi-Fi connectivity
Implemented FOTA update paths tied to real device behavior
Worked through the boundary between low-level firmware decisions and product-level reliability

Strengthened the path from embedded architecture to connected-product behavior that could survive real deployment conditions.

Shows practical ownership of Wi-Fi connected embedded behavior, not just isolated firmware features
Relevant for products that need dependable FOTA paths and predictable field behavior
Useful when the hard part is integration quality, not only low-level code correctness

SeaChange / 2020-2021

Consumer-facing client delivery for large LATAM media platforms

Context: A production subscriber platform where client software quality was visible immediately and scale made regressions expensive.

Client software had to stay dependable in production while integrating with existing systems and serving a large subscriber base.

Roku client softwareHLS streamingbackend connectivity

What I owned: Delivered Roku client software and adjacent integration work in a live product environment where client constraints and platform behavior both mattered.

Delivered Roku client software and related legacy embedded integrations
Worked on product-facing behavior where scale and client constraints both mattered
Connected implementation details to the realities of a live subscriber platform

Helped keep product-facing software reliable in an environment where regressions were visible immediately and scale amplified every mistake.

Relevant for teams that care about stable product-facing behavior under production pressure
Shows experience with legacy constraints and live-platform integration, not only greenfield work
Useful where consumer-visible regressions carry immediate product cost

G2Labs / 2026-present

Python logging utility turned into a reusable public product

Context: A repeated internal tooling problem: console logs were useful but slower to scan than they should be during development, debugging, and small-service work.

The goal was to improve day-to-day Python logging without creating another heavyweight abstraction or private one-off helper that would be hard to reuse later.

PythonloggingPyPI packagingdeveloper tooling

What I owned: Defined the package scope, shaped the thin API, implemented the formatter and helper layer, and published the result as a reusable Python package with public documentation and distribution.

Designed the package around the standard logging module instead of replacing it wholesale
Implemented VT100-colored console formatting, convenience helpers, and optional file logging
Published the package to PyPI and backed it with a public GitHub repository for inspection and reuse

Turned a recurring engineering pain point into a small public product that is installable, inspectable, and reusable across future tooling work.

Useful for clients who need small internal tools and utilities treated with product discipline rather than left as disposable scripts
Shows that G2Labs can package and publish practical Python tooling, not only firmware and browser-side utilities
Relevant when the right answer is a thin, well-shaped developer product instead of a larger platform investment

Credentials

Education, awards, and publications that support the engineering background behind the delivery work.

Education

Academic training

Doctor of Philosophy [paused], Electronics Military University of Technology in Warsaw · 2015-2017
Master of Science in Electronics, Telecommunication Systems Military University of Technology in Warsaw · 2014-2015
Electronics Engineer, Electronics and Telecommunication Military University of Technology in Warsaw · 2010-2014

Awards

Recognition

Rector’s Award of the Military University of Technology for the ZTC WEL team
Diploma for the best thesis
Recognition diploma for distinction in the Dean’s competition for the best thesis
Recognition diploma for academic achievement

Publications

Diagnostic and control software for an interpolating time counter in a programmable device
Interpolating time counter with multi-edge coding
Time interval measurement module implemented in SoC FPGA device
Microcontroller based impedance meter with host computer control
Direct time-to-digital converter with multi-edge coding

Tech stack used in delivery

Tools and platforms used in actual product work, grouped by the kind of problem they helped solve.

Open the full stack page

Embedded targets and firmware

Used in embedded delivery, device bring-up, firmware implementation, RTOS-oriented work, and hardware-adjacent product development.

CC++Zephyr RTOSnRF54nRF52ESP32STM32AVRMSP430MCUbootRTOS kernelsbootloadersFOTAFPGA

Baracoda: ESP32 firmware and field update behavior for an intelligent weight scale
M2MTeam: embedded software in medical robotics work
MicrOS: lightweight RTOS work across startup code, linker flow, kernel surfaces, and board bring-up
Military University of Technology: picosecond time measurement in Xilinx FPGAs

Connectivity and product integration

Used where device behavior has to connect reliably to the rest of the product and survive real deployment conditions.

OpenThreadThreadBLEBLE MeshWi-FiCoAPDTLSMQTTUARTSPII2CREST APIsdevice-to-cloud integration

Baracoda: Wi-Fi connectivity and update flows around the product boundary
Connected-product consulting: firmware, payloads, tooling, and backend touchpoints kept in one thread
Softwarely: BLE Mesh sensoring solutions

Software, tooling, and data

Used for backend integrations, internal tools, delivery support software, web integrations, and product-facing utilities around the device.

PythonNode.jsMongoDBdesktop toolingweb toolingautomation scriptsWordPresscloud servicesQtQEMU

G2Labs delivery work: utility software and web-adjacent tooling around embedded products
SeaChange: software around a production media platform with integration constraints
Internal and client tooling: Python and Node.js where they shortened delivery loops
MicrOS: simulator-backed iteration and sample execution through QEMU

Workflow and engineering environment

Used in daily delivery, debugging, collaboration, and implementation flow across client, product, and open-source work.

GitHubGitLabVS CodeEclipseCMakeNinjawestLinux (Ubuntu)CI workflowsagentic coding (Claude Code)

Client delivery across established teams: GitHub and GitLab workflows
Embedded development: VS Code, Eclipse, and Linux (Ubuntu) in day-to-day implementation
Consulting and product work: CI-backed iteration and handover support
MicrOS: public build flow and contributor-facing tooling around CMake and Ninja
Agentic coding: AI agents for implementation, review, and documentation, with every change still reviewed and owned by an engineer

Client fit

Mostly aimed at established product teams, with enough range to help a startup MVP when the scope is sharp and the bottleneck is real.

Sigma Software GroupBaracodaDisplayLinkSeaChangeSiDLYJM-TronikM2MTeam

Engagement model

One builder, one technical thread, less translation loss.

Discovery stays light, implementation is direct, and the work is sliced around the biggest technical risk instead of presentation overhead.

AI is used where it shortens loops without hiding decisions: research support, scaffolding, documentation, and internal tooling. The final engineering choices still stay explicit, reviewable, and tied to the product context.