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.

Offer 01

Firmware delivery sprint

Fix, stabilize, or ship the firmware slice blocking the product: bring-up, RTOS work, wireless behavior, protocol code, 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
  • 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: payloads, APIs, MQTT or HTTP flows, desktop or browser utilities, 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
  • 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
  • AI-assisted scaffolding, documentation, and internal tooling where it genuinely shortens the loop
  • 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

Worked in client-facing embedded product delivery where implementation work and execution planning had to stay closely aligned.

  • Embedded product-program delivery in a consulting environment
  • Implementation work on delivery-critical product slices
  • Technical risk kept visible in planning and cross-team execution
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

Senior Embedded Software Engineer

Worked on connected embedded product delivery in the Baracoda environment, focused on dependable device behavior and product-side integration.

  • Senior embedded ownership in a connected-product setting
  • Device-side implementation under real product constraints
  • Embedded delivery tied to broader product behavior and field reliability
2021-2023

Alsoft, a Baracoda company

Senior Embedded Software Engineer

Parallel role context listed in the profile for the same Baracoda delivery period, reflecting the company structure around the work.

  • Senior embedded role in the same delivery window as Baracoda
  • Connected-device implementation and product integration context
  • Part of the product environment behind the Baracoda work period
2021-2021

Softwarely

Team Leader

Led the embedded team while delivering BLE Mesh sensoring solutions in a short but management-heavy delivery period.

  • Embedded team leadership
  • Delivery ownership for BLE Mesh sensoring work
  • Hands-on technical leadership rather than coordination-only management
2020-2021

Softwarely

Senior Embedded Software Engineer

Worked as a senior embedded engineer in the same Softwarely period, contributing directly to delivery while moving into team leadership.

  • Senior embedded implementation role
  • Overlap between direct engineering and team leadership responsibilities
  • Delivery in wireless and sensor-oriented embedded work
2021-2021

SeaChange Poland

Client Roku Developer

Developed client application software for the Roku platform in a production media environment serving large subscriber bases.

  • Roku client software in BrightScript
  • Consumer-facing client behavior in production platforms
  • Work shaped by platform constraints and live product expectations
2020-2021

SeaChange Poland

Client Legacy Embedded Engineer

Developed software for legacy Motorola set-top-box platforms together with supporting utility software.

  • Client application development in C for legacy embedded platforms
  • Python utility software around product delivery
  • Production maintenance and evolution under legacy constraints
2019-2020

DisplayLink

Senior Embedded Development Engineer

Short senior embedded engineering period at DisplayLink in late 2019 and early 2020.

  • 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.

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

Sigma Software Group / 2023-present

Embedded delivery under real program constraints

Context: Client-facing embedded product delivery where implementation risk and planning risk affected each other directly.

The work needed embedded execution and delivery planning to stay aligned instead of drifting into separate tracks.

embedded softwareproduct integrationdelivery planning

What I owned: Owned embedded-software delivery on implementation slices where technical decisions directly shaped planning and delivery confidence.

  • Owned embedded software delivery on client product work
  • Worked on the slices where implementation risk directly affected delivery planning
  • Kept technical decisions grounded in what the product team actually had to ship

Useful where teams need firmware execution and realistic planning in the same conversation, not passed between separate roles.

  • Useful when teams need an engineer who can implement and still speak clearly about delivery risk
  • Closer to rescue and execution work than to broad discovery or presentation-heavy consulting
  • Best fit where software and hardware realities have to stay visible in the same conversation

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-2022

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

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

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++ESP32STM32nRF52AVRMSP430ZephyrOSRTOS kernelsbootloadersFOTA
  • 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
  • Profile-backed experience across bare-metal and OS-driven embedded implementation

Connectivity and product integration

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

Wi-FiBLEMQTTCoAPOpenThreadUARTSPII2CREST 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
  • Earlier telemetry-oriented work: hardware interfaces and connected-system integration
  • Profile-based experience explicitly covering MQTT, CoAP, OpenThread, and custom APIs

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
  • Profile-backed range including WordPress and cloud-connected integrations for modern hardware platforms
  • 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 CodeEclipseCMakeNinjaLinux (Ubuntu)CI workflows
  • 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
  • Profile-listed workflow depth including CMake and open-source developer tooling

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.