Modernization
Legacy system migration
Modernize your applications without losing what already works.
We migrate Oracle Forms and Reports to modern, decoupled architectures, assisted by AI. No rewriting your business logic from scratch. No risk to your operational continuity.
- Business logic intact
- Tests at every layer
- Open stack with talent available
The starting point
Your system works. The platform holds it back.
For years, Oracle Forms and Reports were the backbone of thousands of business-critical systems.
Today those same applications face a real challenge. The technology is harder and harder to maintain. Specialized talent is scarce. And the user experience has fallen behind what the business expects.
At ASP Solutions we turn that challenge into an opportunity, with a practice dedicated to migrating those applications to a modern stack.
Benefits
- Lower riskEvery use case is documented and validated before it counts as done.
- Higher speedAI accelerates analysis and code generation without sacrificing quality.
- Guaranteed consistencyOne visual and component standard applied uniformly across the application.
- Future-proof technologyModern stacks, widely supported, with talent available in the market.
- Verifiable qualityAutomated tests at every layer of the architecture.
The stack we use
- Front endReact or Angular, depending on the needs of the project.
- Back endSpring Boot or Python with FastAPI.
- DatabaseOracle to PostgreSQL, combining traditional automation tooling with AI-assisted refinement.
The result is a decoupled, maintainable, scalable system with a coherent, modern interface — built on open standards that the market widely supports.
How we do it
A methodical process, not an "automatic conversion".
AI-assisted migration is neither magic nor a plain code translation. It is a structured process: AI analyzes, documents, and builds, under the supervision and the standards our team defines.
- 01
Defining the visual standard
Before a single screen is migrated, we build the design system: style variables governing the layout, and a library of reusable components — text fields, surfaces, toolbars with default behaviors — that guarantee visual consistency across the migrated application.
- 02
Structural extraction from Oracle Forms
Every form has its entire functional structure extracted: events, data blocks, items, panels, canvases, methods, lists of values, and every relationship between those elements, consolidated into an XML file.
- 03
Intelligent analysis with a specialized AI
That XML is processed by an AI agent trained specifically on Oracle Forms technical documentation, including navigation event orchestration and data block behavior. The agent organizes and structures every element it identifies.
- 04
Use-case inference
From that analysis, the model infers the form’s distinct use cases and produces complete, precise documentation of how it works — the reliable starting point for the migration.
- 05
Front-end and back-end generation
With the visual standards and technical guidelines already defined, the agent generates the front-end and back-end code, cleanly separating the responsibilities of each architectural layer.
- 06
Layered testing
Every migration is validated at multiple levels: API unit tests, validator tests, Angular component tests, and end-to-end tests with Playwright.
- 07
Iterating to completeness
We work iteratively alongside the AI agent until the original use cases are fully covered, making sure no functionality is lost along the way.
Technical questions
What a technical team asks before migrating.
Straight answers to the questions in every technical assessment: architecture, data, triggers, security, testing, delivery, and team.
ArchitectureWhat does the target architecture look like — Angular plus Spring Boot — compared to JFB 3.0?You move from a form-driven runtime to a decoupled web architecture: Angular owns the interface, and Spring Boot owns business logic, persistence, and transactions.
You move from a form-driven runtime to a decoupled web architecture: Angular owns the interface, and Spring Boot owns business logic, persistence, and transactions.
JFB 3.0 mixes interface, logic, and data in a single runtime. The target architecture separates those responsibilities into layers with clear contracts.
- Angular delivers a modern web interface, with reusable components and one uniform visual standard.
- Spring Boot concentrates business rules, transactions, and data access, exposed as a REST API.
- Typed contracts between layers: each part is tested, scaled, and evolved on its own.
Business behavior is preserved. What changes is where it lives — and how easy it is to maintain.
DatabaseWhat happens to the database logic — the packages and stored procedures?Your PL/SQL can stay where it is. What changes is who calls it: only the Spring Boot back end, behind a gateway — Angular never talks to Oracle directly.
Your PL/SQL can stay where it is. What changes is who calls it: only the Spring Boot back end, behind a gateway — Angular never talks to Oracle directly.
Packages that have worked for years are not rewritten for the sake of rewriting.
- Proven procedures are kept: Spring Boot calls them behind a business-oriented API.
- Oracle details stay isolated: typed data travels outward, never database internals.
- Only what adds value moves: a rule moves to Spring when it can be tested without Oracle and its equivalence verified.
Less risk today, and the freedom to decouple the database tomorrow.
TriggersHow are form-level triggers and Oracle built-ins like Commit_Form or ROLLBACK handled?Triggers are never copied line by line: they are migrated by meaning. Commit_Form becomes a transactional API operation, and ROLLBACK becomes a controlled exception.
Triggers are never copied line by line: they are migrated by meaning. Commit_Form becomes a transactional API operation, and ROLLBACK becomes a controlled exception.
Every trigger is classified by what it actually does, and that intent is implemented in the right layer.
- Navigation and interface → the Angular lifecycle.
- Validation → in the form to guide the user, and on the back end as the final authority.
- Transactions → Spring Boot services: committing is a business operation, not a button.
The result behaves like the original — and ends up documented and tested.
SecurityHow do you handle logging, exception handling, validation and security?Angular guides the user; Spring Boot protects the system. Every validation and authorization decision is made on the back end, with centralized audit and errors that never expose internals.
Angular guides the user; Spring Boot protects the system. Every validation and authorization decision is made on the back end, with centralized audit and errors that never expose internals.
- Double validation: on the front end as a usability aid, on the back end as the rule that actually decides.
- Controlled exceptions: a global handler translates every failure into a clear, safe message.
- Structured logging: correlation identifiers to audit every operation end to end.
Disabling a button is never a security decision: security lives on the back end.
AuthenticationWhat is the authentication flow between Angular and Spring Boot, and where is it stored?A modern identity provider — such as Auth0 — authenticates the user with the OAuth2 and OIDC standards. Angular starts the session and Spring Boot validates every token, on every operation.
A modern identity provider — such as Auth0 — authenticates the user with the OAuth2 and OIDC standards. Angular starts the session and Spring Boot validates every token, on every operation.
- No home-grown passwords: identity is managed by a specialized, certified provider.
- Short-lived tokens instead of fragile sessions: every request arrives signed and verifiable.
- Authorization per operation: the back end decides what each user can do, always.
More secure than the original scheme — and ready for corporate single sign-on (SSO).
TestingWhat testing tools and strategy do you apply, front end and back end?Tests at every layer, and each layer catches a different risk: unit tests in Angular and Spring Boot, integration against the real database, and end-to-end with Playwright.
Tests at every layer, and each layer catches a different risk: unit tests in Angular and Spring Boot, integration against the real database, and end-to-end with Playwright.
- Angular: Jasmine, Karma, and TestBed for components and validators.
- Spring Boot: JUnit 5, Mockito, and MockMvc for business rules and the API.
- Integration: Oracle packages are tested against the real database, not against mocks.
- End-to-end: Playwright verifies complete flows exactly as the user experiences them.
The acceptance criterion is covering the original system’s behavior, not reaching a percentage.
DeliveryHow is the application built and deployed?With GitLab CI/CD and immutable artifacts: every release is built once and promoted across environments. Production requires explicit approval, and there is always a way back.
With GitLab CI/CD and immutable artifacts: every release is built once and promoted across environments. Production requires explicit approval, and there is always a way back.
- One artifact per layer: front end and back end are built and deployed independently.
- Promotion across environments: what reaches production is exactly what was already validated.
- Immediate rollback: every release keeps its predecessor ready to switch back.
Application and database deployments stay separate, each at its own pace and with its own control.
TeamWhat technical skills does a team need to run a migration like this?Day to day is carried by two profiles — application development and DevOps engineering — with targeted support from an Oracle and PostgreSQL specialist.
Day to day is carried by two profiles — application development and DevOps engineering — with targeted support from an Oracle and PostgreSQL specialist.
- Application development: Angular and Spring Boot on top of the architecture already defined.
- DevOps engineering: delivery pipeline, environments, and observability.
- Database specialist: steps in when Oracle behavior gets complex.
The hard part is not building screens: it is preserving the original system’s behavior and proving equivalence with tests. That is exactly what our methodology and our team are for.
Get started
Your Oracle Forms system holds years of business knowledge. We carry it into the future.
Do you have applications built on Oracle Forms and Reports? Let’s talk. We’ll show you how to take them to a modern stack — with the logic that runs your business intact.