Senior-led engineering. Purpose-built software.

devFlorencebuilds dedicated software your business can run on.

Senior-led engineering for dedicated applications, AI-assisted legacy modernization, integrations, and AWS-native platforms shaped around your business processes and operational reality.

Explore services Start a conversation

Built for your business processes

Stop bending your operations around generic SaaS platforms. Get dedicated software designed to support the processes that create value in your business.

Your rules, your process logic
Your data, your control
Your operational advantage

YourDomainService.java

01public class YourDomainService {
02  public Result solve(BusinessProblem problem) {
03    // Understand the domain
04    // Model the right abstractions
05    // Implement only what matters
06    // Deliver real value
07
08    return Result.success();
09  }
10}

What we build

▣Process-driven applicationsFocused web and enterprise software that implements your actual business rules.

⌘APIs & integrationsClean service boundaries, reliable integrations, and systems that communicate without friction.

◉Data & automationOperational data, automated decisions, and process visibility where it creates business value.

▱Reactive platformsJava, serverless, and event-driven foundations for resilient, scalable systems.

Freelance software development led by Alessandro De Stasio. Senior expertise. Direct collaboration. Focused, reliable results.

30+years experience

28years Java

1:1senior collaboration

Focused delivery modelDirect collaboration with a senior technical owner reduces coordination overhead and shortens the path from process understanding to working software.

What devFlorence is

A senior-led, AI-assisted software studio.

devFlorence combines 30+ years of software engineering experience, 28 years on the Java technology stack, practical architecture, and modern AI-assisted execution. Senior judgment owns every technical decision while AI reduces mechanical work across analysis, implementation, testing, and documentation.

Custom-fit software

Software should support the processes that create your advantage.

Generic SaaS products are built for averages. devFlorence builds dedicated applications that reflect your process logic, business rules, data flows, and operational constraints.

The devFlorence approach

Purpose-built systems instead of SaaS-shaped compromises.

We implement only what creates value, focus the product around the process requirements that matter, and shorten the path from idea to market without adding operational bloat.

Your processes first Only useful features Domain-specific model Faster path to market

Services

Focused engineering for applications your business depends on.

devFlorence develops systems shaped by business processes and modernizes established applications through controlled, incremental change. The work combines senior architecture, modern Java engineering, AI-assisted execution, and production-focused delivery.

Dedicated business applications

Focused tools, internal platforms, APIs, automation, and process systems designed around your real operating model.

02Java-first · not Java-only

AI-assisted legacy modernization

Controlled modernization for Java and non-Java systems. AI accelerates discovery, specifications, tests, and repeatable transformations while senior engineers retain production accountability.

Architecture & technical leadership

System design, technical direction, trade-off analysis, and architecture that stays understandable after the first release.

Cloud, serverless & integration

AWS-native systems, event-driven design, real-time messaging, and integration layers that avoid unnecessary operational weight.

Legacy modernization

Move critical software forward without rewriting the business.

Legacy applications contain years of business knowledge that should be preserved. devFlorence combines senior engineering with LLM-assisted analysis to recover intent, establish a verified behavioral baseline, and modernize Java and non-Java systems incrementally.

Discuss a modernization path

Understand

Map code, dependencies, data, integrations, domain language, and operational constraints before choosing a target architecture.

Protect

Recover specifications and establish characterization tests that preserve essential behavior while the system changes.

Transform

Modernize in place or migrate selectively to current Java, standards, and cloud services where they create measurable value.

Verify

Use automated tests, traceability, observability, staged releases, and rollback plans to keep every step reviewable.

Java + LLMs

Modern Java gives LLM-assisted engineering strong rails.

Java's stable specifications, explicit types, predictable structures, and mature testing ecosystem give coding agents useful constraints. AI can accelerate implementation and refactoring while engineers retain a clear path to understand and verify each change.

This approach is informed by Adam Bien's pragmatic, standards-first work. Alessandro worked in an international team led by Adam and has attended Airhacks workshops since 2018, most recently Spec-Driven Java Development at LLM Speed .

Principles

Simple systems. Clear ownership. Production discipline.

devFlorence keeps the engineering surface intentionally focused: clear process models, explicit boundaries, modern Java foundations, and AI assistance under senior technical control.

KISS, YAGNI, DRYPrefer simple designs that solve today’s process requirements. Avoid speculative features, duplicated logic, and abstractions without evidence.

Process model firstEncode the business process clearly: rules, states, decisions, data ownership, and the language your team already uses.

Production‑ready architectureChoose boring where possible and modern where useful: Java, serverless, reactive patterns, observability, and maintainable boundaries.

AI-assisted, not vibe-codedAI helps explore, implement, and validate faster — but architecture, security, tests, and production accountability remain engineering-owned.

A complete messaging product, built with engineering depth.

Neurons is an integrated messaging platform deployed in the customer's AWS account. It combines Matrix-compatible E2EE for messages and attachments, elastic serverless scaling, real-time push delivery, Matrix server-server federation, and an extensible foundation for domain products.

Explore Neurons Talk about product engineering

Early Access · September 2026 · Up to 5 organizations

Secure end-to-end encrypted messaging, Matrix-compatible and built to scale.

www.neurons.run

Web client Neurons web client E2EE messages + attachments

Real-time push

Customer AWS account Neurons AWS serverless Lambda-native · AppSync Events · DynamoDB · S3

Matrix federation

Matrix ecosystem Synapse + other homeservers Federated rooms and messages

Secure by designMatrix-compatible E2EE protects message content and attachments between participating clients.

Elastic AWS operationRuns in the customer's AWS account, scales with demand, and delivers updates through real-time push events.

Federated and extensibleMatrix server-server federation connects homeservers while dedicated software adds domain-specific capabilities.

01 Architecture under pressure

Federation, message flow, event propagation, AWS services, and reliability trade-offs.

02 Brand + product thinking

Not only implementation: positioning, UX, visual identity, and technical storytelling.

03 The devFlorence method

Senior judgment, focused scope, lean delivery, and AI-assisted execution applied to a real product.

Alessandro De Stasio

Software architect, developer, and founder of devFlorence.

About

Direct senior ownership from architecture to production.

devFlorence is a senior-led software studio founded by Alessandro De Stasio, bringing 30+ years of software engineering experience and 28 years on the Java technology stack.

Trusted AI agents extend research, implementation, testing, documentation, and delivery speed — but architecture, trade-offs, code quality, and production decisions remain senior engineering responsibilities.

Alessandro's experience includes working in an international team led by Adam Bien and continuing professional development through Airhacks workshops since 2018, including the 2026 course on spec-driven Java development with LLMs.

Compared with a traditional agency, the model is lighter and more direct: fewer layers, faster decisions, and continuous technical ownership grounded in the process, the architecture, and the long-term cost of the software.

30+years software engineering

28years Java stack

1:1direct senior collaboration

Contact

Have a software idea that felt too complex, too slow, or too expensive to build?

Tell me about the application, legacy system, integration, automation, or process improvement you have in mind. devFlorence can help you evaluate the technical path, reduce unnecessary scope, and turn difficult requirements into focused software your business can run on.