Senior-led engineering. Purpose-built software.

devFlorencebuilds dedicated software your business can run on.

Senior-led engineering for dedicated applications, Java application migration, 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 migrates established applications through controlled, incremental change. The work combines senior architecture, modern Java engineering, lean technology choices, and production-focused delivery.

Dedicated business applications

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

02Java · Java EE · Quarkus

Java application migration

Incremental migration to current Java, Jakarta EE, MicroProfile, Quarkus, GraalVM, and cloud or serverless deployment with fewer dependencies.

Explore Java application migration

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.

Application migration

Move critical applications to a leaner Java and cloud stack.

devFlorence migrates established Java and Java EE systems with current Java, Jakarta EE, MicroProfile, Quarkus, and GraalVM. The path is incremental, dependency-conscious, and directed toward cloud or serverless deployment where it reduces operational work.

Explore the Java migration service

Assess

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.

Migrate

Upgrade, replace, or extract one bounded part of the system using current Java and the smallest useful technology set.

Deploy

Release the accepted increment to cloud, serverless, or container infrastructure with observability and rollback controls.

Java migration stack

A mature ecosystem for controlled change.

Java, Java EE, Jakarta EE, MicroProfile, Quarkus, and GraalVM provide stable contracts, explicit types, mature tests, compact runtimes, and practical deployment options from containers to AWS Lambda.

AI-assisted analysis can reduce mechanical work during discovery and migration, while engineering review remains authoritative. The approach is informed by pragmatic, standards-first Java practices and recent Airhacks work on spec-driven Java development with LLMs .

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.

ECB architectureOne of the most effective architectural patterns for Java applications, Entity–Control–Boundary separates domain state, use-case coordination, and external interfaces. It keeps business logic explicit and testable while giving LLMs a clear, understandable structure for AI-assisted development.

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.