A software factory, in the literal sense
A factory is a system that produces reliably. bytefactory applies that idea to software delivery: repeatable process, measured output, and quality controls built into the line — run by a small team of senior engineers.
Why we started it
bytefactory was started by engineers who spent years inside consultancies and product companies watching the same failure repeat: delivery treated as craft heroics instead of an engineered system. Estimates drifted, quality depended on who happened to be staffed, and handovers left clients dependent on their vendor.
We built the company around the opposite premise. Delivery is a production system: it has inputs, controls, and measurable output. When the system is good, quality stops depending on luck.
Today we work with teams in healthcare, media, SaaS, and travel — modernizing what is brittle, embedding AI where it shortens real work, and leaving behind platforms our clients run without us.
Four principles behind every engagement
Evidence over adjectives
We report progress in numbers and working software, not status adjectives. If a claim cannot be demonstrated, we do not make it.
Built to hand over
Every system we deliver is designed for the team that inherits it: documented, tested, and free of dependencies on us.
Constraints are the job
Compliance, legacy, budget, and deadline are not obstacles to the work — they are the work. We plan with them from day one.
Small senior teams
Two to four experienced engineers who stay for the whole engagement, not a rotating bench billed by the head.
Senior engineers, no bench
Everyone who writes code here has shipped and operated production systems, and everyone who talks to clients writes code.
Angel Freire
Self-taught programmer, team builder, and tech entrepreneur. Angel started bytefactory to turn software delivery into an engineered system — and still writes production code on client work.
Engineering
Fixed-scope and agile engagements both — the delivery model adapts to the client, the engineering habits do not. Tests lead the work (TDD, and BDD where the domain earns it), every repository ships with CI/CD — GitHub Actions, GitLab, or Jenkins — and local development environments keep iteration fast.
The systems we build this way serve thousands of concurrent users.
Platform & cloud
GitOps is the default: the platform lives in a repository, ArgoCD reconciles it onto Kubernetes, and everything runs in containers. We run production on AWS and Azure, practice FinOps so the bill is engineered like the platform, and happily reach for DigitalOcean or managed platforms like Vercel when they fit better.
Monitoring is built on metrics, with alerts tuned for early insight — proactive, not reactive.
AI & data
LLM features in production: embeddings and retrieval, third-party integrations, and direct work with the OpenAI and Anthropic APIs — or through abstractions like Pydantic AI — with Langfuse for observability.
On the data side, Airflow pipelines feed warehouses and data lakes, surfaced in Looker Studio and Metabase.
Delivery
Delivery is measured, not narrated. Engagements ship with delivery metrics — lead time, deployment frequency, change failure rate — and product health metrics implemented, monitored, and reported.
The dashboards we read are the same ones the client sees.
Meet us over a problem, not a deck
Bring something that is stuck. The first conversation is an engineer, not a salesperson.