ai-focused software housePoland — remote across the WORLD

Prototype in days.Production systemsthat hold up.

PrudentCode is an AI-focused software house. We build SaaS platforms, CRM systems, mobile applications and IoT products — from considered UX and interface design, through architecture, the data model, backend and integrations, to the cloud and the devices they run on. Every architectural decision and every line of code that reaches production is owned by an experienced engineer.

Start a project →See our work →
Practice 01
SaaS platforms
Practice 02
CRM & internal systems
Practice 03
Mobile applications
Practice 04
IoT & edge AI
services

Four practices, one team and responsibility for the whole product.

We do not treat a project as a list of hours to be worked through. We take responsibility for design, architecture, frontend, backend and deployment — and on IoT projects, for what happens on the device itself.

01

SaaS platforms

We design SaaS products with later growth in mind: isolation of client data, roles and permissions, billing, and an API that does not have to be rebuilt at every next stage of development.

Nest.jsFastAPIPostgreSQLGraphQLStripe
  • Multi-tenant architecture where the product model calls for it
  • Roles, permissions and data isolation between organisations
  • Subscriptions, payments, invoicing and plan limits
  • REST and GraphQL for web and mobile applications and for integrations
  • Indexes, caching, job queues and asynchronous processing from the start, where they are needed
02

CRM & internal systems

Clients, offers, projects, documents and settlements in one coherent system — instead of a process scattered across spreadsheets and tools that have stopped talking to one another.

RBACPDFIntegrationsReportingAudit log
  • A data model covering the whole process — from lead to delivery and settlement
  • Roles and permissions that go down to the individual record where needed
  • Document generation and integrations with mail, calendar, accounting and external systems
  • Reporting directly on the application data, and at larger scale with a separate analytical layer
  • Change history and an audit log where the process requires a full audit trail
03

Mobile applications

We match the technology to how the product is actually used. When the mobile app extends a web system, we share code where that makes sense. React Native comes in when offline work, native features or a more demanding mobile UX are needed.

ReactCapacitorReact NativeExpoPushApp Store / Play
  • React plus Capacitor for apps that share much of their logic with the web
  • React Native and Expo for offline work, native features and a demanding mobile UX
  • One API and shared data contracts for the web and the mobile application
  • Publishing on the client’s own developer accounts
  • Push notifications, error monitoring and observation of real usage
04

IoT & edge AI

We connect cloud software with what happens on the device: local inference, telemetry, provisioning and remote management of a fleet working outside the controlled environment of a datacenter.

Raspberry Pi 5Computer VisionMQTTOTAEdge AI
  • Vision pipelines and AI models run locally, optimised for the resources of the device
  • Device provisioning and telemetry over MQTT
  • Operation over an unstable connection, with local buffering of data where the system requires it
  • OTA updates, remote configuration, diagnostics and fleet monitoring
  • Secure device-to-cloud communication: TLS, per-device certificates, mTLS, ACLs on MQTT topics and credential rotation
how we build

Fast where it is cheap, slow where it counts.

Modern tooling shortens the road to the first working version considerably. It does not shorten the work on architecture, security or the data model — so the time saved on implementation goes into exactly those decisions.

01

Analysis first, then the right next step

We start by understanding the goal, the scope, the users and the constraints of the project. What the analysis finds decides the route: on smaller systems we can often move quickly to a prototype or a first version of the product. On larger ones we begin with mockups, user flows and putting the architecture in order, before implementation proper starts.

analysis → the right route → design and architecture → build
02

AI agents write, a human answers for it

AI agents speed up implementation here considerably, but they do not make decisions for the team. Architecture, the data model, security and every piece of code that reaches production are verified by an experienced engineer.

AI speeds up implementation · responsibility stays with a human
03

Evidence-based UX

Interface decisions rest on watching users, on data and on real flows, not on intuition alone. Findings are tied to specific screens and interactions, and recommendations follow from what actually happens while the product is being used.

observation → data → conclusions → design decisions
process

We start with analysis, not with code.

The order matters here. Every stage ends with something that stays with you — a document, a module or a working deployment — and you can stop after any of them.

01

Discovery & analysis

A paid, fixed stage ending in a document: scope, data model, risks and staged estimates. The document is yours — even if someone else builds from it.

02

Architecture

Stack choices with reasons, service boundaries, the data model and a deployment plan. Every decision is recorded together with what would make us change it.

03

Build in milestones

Each milestone ends with a working part of the system, accepted on its own. After the first one you can usually start working in the system.

04

Run & evolve

Monitoring, fixes and further modules — as a monthly block of hours or hourly. The code is written in your repository from the first commit, and the transfer of rights is settled in the contract.

Backend architecture

Modular and distributed systems, event-driven architecture and microservices designed for maintenance, observability and further development.

AI & vision pipelines

Detection of people and objects, image analysis, OCR and the integration of AI models — in the cloud or directly on the device.

IoT platforms

Device provisioning, telemetry, remote configuration and OTA updates for devices working in the field.

Real-time communication

MQTT, WebSockets and secure data exchange under an unstable or intermittently unavailable network.

APIs & integrations

REST and GraphQL, integrations with external systems, payments, authentication and identity providers.

Cloud & DevOps

Docker, AWS and GCP, automated CI/CD, environment management and repeatable deployments.

Data processing

Ingestion, extraction and transformation pipelines — from documents and images to structured records ready for further processing.

Performance

Indexes, caching, queues, aggregations and inference optimisation — for high-traffic systems and for resource-constrained devices alike.

selected work

Systems, end to end.

An AI product of our own, a commercial deployment running models on devices, and a document platform from the OCR pipeline up to the user-facing app. The fourth entry is a capability rather than a delivered project, and is labelled as one.

own product

JourneyLens — UX audit from screen recordings

journeylens.io
Multi-model AIGeminiVideo pipelineRAGCloud RunGCP
  • The input is a product session recording; the output is a user-journey diagram and a list of concrete UX findings — in minutes, not after a week of watching sessions by hand
  • Three models analyse the same recording and cross-check one another: a finding only one of them sees does not become a recommendation
  • The video pipeline streams large files straight into the model resumable upload API instead of buffering them on the way — with heartbeat progress visible in the interface
  • Analyses run as background jobs on Cloud Run with CPU throttling disabled — the request returns immediately while processing continues; the service runs in europe-west1 with secrets in Secret Manager
production system

Edge AI platform for devices in the field

commercial deployment · details kept confidential
Computer VisionRaspberry Pi 5MQTTOTAFleet management
  • Detection and image analysis computed locally on the device — frames never leave it, only results travel to the cloud
  • Raspberry Pi 5 as the target platform: the model is optimised for the compute budget of the device, not for a datacenter GPU
  • Devices report over MQTT and are designed for unstable LTE — losing the link does not stop the device from working
  • Provisioning, remote updates and monitoring through one API — most changes and diagnostics need no physical access to the device
architecture

Private AI — deployment options for data that cannot go to a public API

a capability and a lab, not a delivered deployment
Local LLMOn-premisePrivate cloudVPCRAGDocker
  • Contracts, employee data, internal documentation — some material is not sent to a public API. There are two ways to handle it, and the choice is worth making deliberately, before the first prototype exists
  • On local infrastructure: the model sits on your servers and nothing leaves the network. We keep our own machine running local models, so an approach can be tested on your documents before anyone signs a data-processing agreement
  • In the cloud but isolated: private connectivity to the model service (dedicated VPC, private endpoints) in an EU region, on a service whose terms exclude using your data for training — something to confirm for the specific provider rather than assume
  • The architecture is identical in both: retrieval, evidence under every conclusion, structured output. The only thing that changes is where the inference runs
  • We state the trade-off plainly: a local model is weaker than the best hosted ones. So we start by measuring that gap on your documents, and only then make a recommendation
own product

Document intelligence — from PDF to a searchable product

own platform built single-handedly · pipeline and product
Tesseract OCRPDFPythonNode.jsGraphQLReact
  • A PDF to image to OCR to product-record pipeline, run asynchronously in a queue rather than inside an HTTP request
  • Thousands of products refreshed on every publishing cycle, with no manual data entry
  • Output normalised into searchable records — name, price, validity period — not raw text; the whole difficulty sits in the edge cases: poor scans, multi-column layouts, prices printed as graphics
  • A consumer product was built on that pipeline: a store map from the Overpass API with proximity search, shopping lists, and one GraphQL API for the web and mobile clients
  • From the scraper to the account system — the whole stack was built solo, which is why no part of it is a black box to us
stack

Backend

  • Node.js — Nest.js, Express
  • Python — FastAPI, Flask

Frontend

  • React
  • Next.js

Mobile

  • React + Capacitor
  • React Native / Expo

Databases

  • PostgreSQL · MySQL
  • MongoDB · Redis

AI / Data

  • Computer Vision
  • OCR — Tesseract
  • RAG & agents
  • Local LLMs (on-premise)

IoT

  • Raspberry Pi · MQTT
  • OTA updates
  • Provisioning

Cloud & DevOps

  • AWS · GCP · Vercel
  • Docker · DigitalOcean
  • GitHub Actions

Architecture

  • Microservices
  • Event-driven systems
  • Real-time systems

The core of the team is two roles: an experienced software engineer and a PM/PO with years of product work behind them. The hardest decisions in a project are rarely purely technical — the architecture has to survive years of further development while the product meets business goals here and now. That balance between engineering and product is the basis of how we work.

Scope

Design, architecture, frontend, backend, the data model and integrations — responsibility for all of it stays with us.

What that changes

You do not get an architect, a developer and someone translating between them as separate people. Technical and product decisions are made inside one team, without intermediate layers and long handovers of context.

Languages

Polish — native. English — C1. We run projects and technical discussion in both.

insights

Notes from building systems.

Short pieces about the decisions we make on projects — and what follows from them after launch.

PrudentCode

Building Software with AI: From Prototype to Production

Artificial intelligence is changing the way software is built faster than most teams can update their sales presentations. In a few minutes, it is now possible to generate a piece of…

AI software developmentsoftware engineeringproduct development
PrudentCode

Computer Vision and IoT in Production Management

On a production floor, many important signals never appear in an ERP system, spreadsheet or report. They can be seen through a camera, heard in the way a machine operates or measured by a…

Computer VisionIoTEdge AIproduction systems
PrudentCode

Digitising Local Service Businesses with RAG and Local AI Models

Until recently, digitisation for a local service business often started and ended with an email inbox and a spreadsheet. Sometimes there was also a notebook containing customer phone…

RAGlocal AIDocument Intelligencedata privacy
All articles →
contact

Have a system that
simply has to work?

Tell us what should be built, who will use it and which parts are the most critical. We reply within one working day — usually straight away with the questions that pin down the biggest risks and the next step.

Based inPolandremote across the WORLD · mostly CET timezone

The message comes straight to us. We use it only to answer your enquiry.