AtlasSAP and the community

All ecosystems

Find and compare artifacts and content across SAP development ecosystems, connected through shared capabilities in the graph.

161Capabilities 1289Artifacts 1052Content 7Ecosystems

Each capability, artifact and content item is counted once, including those shared across ecosystems.

Explore by ecosystem7

CAP95 capabilities · 439 artifacts · 608 content UI539 capabilities · 226 artifacts · 97 content ABAP75 capabilities · 453 artifacts · 203 content BTP/BAIP77 capabilities · 312 artifacts · 523 content SAP Commerce2 capabilities · 3 artifacts · 0 content SAP SuccessFactors1 capabilities · 1 artifacts · 0 content SAP Digital Manufacturing2 capabilities · 5 artifacts · 1 content

Explore by domain10

Protocols & APIs13How a service is reached and what it speaks: the protocols it answers, the formats on the wire, the errors it returns, and how a client is written against it.Data & Persistence26Everything between the model and the rows it becomes: the shape of the data, which database holds it, how it changes safely, and what is kept when it is deleted, cached or copied.Integration & Messaging13How one system talks to another without becoming it: destinations, events, RFC calls, integration flows, and the documents and notifications that leave the application.AI & Agents15What a model or an agent is given and allowed to do: access to the code, the tools it may call, the retrieval behind its answers, and the guardrails around all of it.Security & Compliance13Who is calling, what they may do, and what has to be recorded: authentication, authorization, audit, secrets and certificates, and the checks that keep input and dependencies safe.Operations & Runtime20Running the application once it is built: where it runs, how it is deployed and configured, tenants and jobs, and how it reports on itself while it runs.Developer Experience30The work of building: the editor and the local server, generators and tests, linting and debugging, and how code is reviewed and versioned before it ships.UI & Frontend Bridge24Where the service meets a screen: annotations and data binding, the launchpad, theming and localization, and what a UI needs from the backend to render.Process & Workflow4Work that spans people and systems over time: business processes that are automated, and the workflow steps a person completes inside them.Learning & Reference3What to read before writing code: the documentation, the conventions, and the reference applications that show a whole thing working.

Capabilities161

Shared capability names describe the task across ecosystems. Open an ecosystem for its own wording and coverage assessment.

161 of 161 capabilities

CapabilityEcosystems

ABAP Cloud readiness

Whether code can run in ABAP Cloud — released APIs only, no direct table access, no obsolete statements — and what to do with the code that cannot.

ABAP

Accessibility

Making a UI usable with a screen reader, with a keyboard alone and without seeing the layout: accessible names on controls, a heading order, landmarks, focus handling and announcements.

UI5

Account provisioning

Setting up cloud accounts, their organisational structure, resource entitlements, subscriptions and access assignments so the setup can be repeated from code.

BTP/BAIP

Agent access to your code

Letting a coding agent read the project or the system you actually have, reach its model, its objects and its checks, and act on it.

CAP ABAP UI5 BTP/BAIP

Agent access to your systems

Giving an AI agent access to the business data, configuration or operations of systems you run through an MCP server.

BTP/BAIP ABAP CAP SAP Commerce SAP SuccessFactors

Agent evals

Knowing whether an AI feature still behaves after a model, prompt or schema change.

CAP BTP/BAIP ABAP

Agent guidance

Packaged knowledge you hand a coding agent so it gets a framework right unprompted — skills, rule files, instruction packs.

CAP UI5 BTP/BAIP ABAP SAP Commerce

Agent tooling

Building an agent into your own application — the tools it may call, the state it keeps between turns, and the framework it runs in.

CAP BTP/BAIP

Agent workspaces

Giving people a workspace to direct agents, retain the context of a task and interact with its results across connected applications.

BTP/BAIP

Analytic modelling

Defining what an analytical client actually reads — the multi-dimensional layer between stored rows and a chart: measures, dimensions, hierarchies, filters and parameters, and the associations somebody navigates them by.

BTP/BAIP ABAP

Analytical models

Marking up a CDS model so an analytical front end can read it as a cube rather than as a list of rows, and serving it over the protocol that front end speaks.

CAP

Analytical queries

Grouped, aggregated and filtered reads for analytical clients, answered by the database rather than in application memory.

CAP

App hosting

Where a built frontend lives and what serves it — the static files of a frontend application after the build, reachable behind a login and beside the API it talks to, without a web server of your own.

BTP/BAIP UI5 CAP

Application runtimes

The environments that execute application code and manage its processes, containers or managed language runtime.

BTP/BAIP

Architecture diagrams

Drawing the architecture and components of a solution so another person can understand their responsibilities and connections.

BTP/BAIP

Async processing

Doing work outside the request that triggered it, with a guarantee that it eventually happens — deferred jobs, retries, and periodic work.

CAP ABAP BTP/BAIP

Attachments

Storing a file somebody uploaded next to the record it belongs to, and getting it back out — where the bytes actually live, who may read them, and what the UI shows while they are being scanned.

CAP UI5 ABAP BTP/BAIP

Audit logging

Recording who touched personal or sensitive data, in a form an auditor accepts, without hand-writing it in every handler.

CAP BTP/BAIP

Authentication

Establishing who is calling: validating credentials or tokens, resolving the user, and making that identity available to the application.

CAP BTP/BAIP ABAP UI5

Authorization

Deciding who may read or change what, at service, entity and instance level — role checks, forwarded user context, and restrictions evaluated as query filters rather than after the fact.

CAP BTP/BAIP ABAP

B2B message mapping

Defining the structure of business messages exchanged between partners using different standards, and mapping one structure onto another.

BTP/BAIP

Browsing table data

Looking at what a system holds while developing or supporting it: the rows behind a key, the reference data a field points at, the tables that carry data for one object.

ABAP

Build and dev-server tooling

Serving an app locally and building it for deployment — proxying a backend, transpiling, bundling, and shaping the result for whatever will host it.

UI5

Caching

Holding the result of an expensive read so the next one is cheap.

CAP BTP/BAIP ABAP

Calling a service by hand

Sending a request to an OData service or a push channel on a system and reading what comes back, while building it or chasing an error, before any client exists.

ABAP

Cataloguing and lineage

Finding what data exists across the estate and what it promises — catalogs and data products, the contract a consumer can rely on, where a field came from, and what a column actually contains once you profile it.

BTP/BAIP

Certificate management

Keeping the certificates a system trusts and presents over TLS current: importing root and intermediate CAs, requesting and importing its own signed certificate, and replacing one before it expires.

ABAP BTP/BAIP

Change promotion

Moving a change through the environments of a landscape, from development through test to production, and knowing which change has reached which environment.

ABAP BTP/BAIP CAP UI5

Change tracking

Keeping a readable history of what changed on a record, who changed it and when — as business history rather than database journalling.

CAP ABAP

CI/CD pipelines

A pipeline that builds, tests and delivers an application each time its source repository changes, with a build log that shows which step failed.

BTP/BAIP CAP

Clean code conventions

The naming, structure and language-subset conventions that make source code readable across a team — and the question of which of them a checker can enforce.

ABAP

Code formatting

Making source match one layout — indentation, keyword case, the shape of a statement block — by rewriting it rather than by reporting on it.

ABAP

Code metrics

Measuring source code: its size, the complexity of its conditions, the coupling between classes and the cohesion inside one, and showing where those numbers concentrate across a package.

ABAP

Code review

Reading a change before it moves on: which files or objects a change contains, what changed in each since an earlier version, and what a reviewer decided about each part.

ABAP

Concurrency control

Stopping two people who opened the same record from silently overwriting each other — detecting that the version you read is no longer the version you are saving over.

CAP

Configuration

Per-environment settings without per-environment code — profiles, layered configuration, and bindings resolved from the platform at start-up.

CAP ABAP

Consumption monitoring

Knowing what a cloud account consumes as it runs, in credits, capacity units and cost per service and organisational unit, and being warned before a budget is spent.

BTP/BAIP

Content filtering

Checking what goes into a model and what comes out of it against content rules, and stopping or flagging a request that fails them.

BTP/BAIP CAP

Custom controls and libraries

Extending the set of controls an app is built from: a control of its own, a wrapper around a third-party widget, or an icon font registered with the framework, packaged so another app can reuse it.

UI5

Data binding

Keeping a control and a model in step in both directions, including the formatting, type conversion and validation that sit between the two.

UI5

Data federation

Reading data that lives in another system as if it were local — by federating the query, by copying the rows, or by caching what was read.

CAP BTP/BAIP

Data masking

Replacing the personal or confidential values in a prompt with placeholders before it leaves for a model, and putting them back in the answer.

BTP/BAIP CAP

Data modelling

Defining the shape of data before anything serves it: entities and their types, how they relate, and the projections and views that services and applications consume.

CAP ABAP

Data privacy

Doing what the law requires with personal data — knowing which fields are personal, answering a subject's request about them, and deleting them when the reason for holding them expires.

CAP ABAP BTP/BAIP

Database administration

Running the database a project uses once it exists: watching its health and performance, managing users and their access privileges, and keeping backups that a recovery can rest on.

BTP/BAIP

Database connectors

Connecting an application’s data model and queries to a database, including the differences in supported queries, types and schema management between database implementations.

CAP BTP/BAIP ABAP

Debugging

Seeing what running code did between an input arriving and a result coming out: which code ran, what the values were at each point, and why a value ended up as it did.

CAP ABAP

Dependency injection

Wiring an object's collaborators from outside it, so a class can be swapped for another implementation without editing the code that uses it.

ABAP

Deployment

Getting an application onto a runtime and keeping it there: build descriptors, deployment topology, service bindings and lifecycle operations.

CAP BTP/BAIP

Deployment and operator

Automating the build and deployment of a project with multiple modules: generating deployment descriptors and coordinating build, migration, deployment and validation commands.

CAP BTP/BAIP

Destinations

Reaching a system that is not yours — an S/4HANA tenant, an on-premise service, a third-party API — without the address, the credentials or the tunnel being written into the application.

CAP BTP/BAIP UI5

Document extraction

Getting structured data out of a document somebody sent you — an invoice, a purchase order, a scanned form — instead of having a person key it in.

BTP/BAIP CAP UI5

Document output

Producing a document a person receives — a printed form, a generated PDF, a filled template — and getting it to a printer or a queue rather than returning it as a payload.

CAP ABAP BTP/BAIP

Documentation

Finding the answer in what has already been written, and writing it where it has not — first-party documentation made searchable by something other than a person scrolling it, including by an agent, and a document of custom code produced from the code itself.

CAP UI5 BTP/BAIP ABAP

Draft handling

Letting a user edit a record over several requests before it becomes real — saving unfinished changes, locking, and activating a completed draft.

CAP

Driving the SAP GUI

Operating the SAP GUI programmatically to perform tasks or test interactions through the actual screen.

ABAP

Editor support

Working in source code with the editor helping rather than treating it as text — completion, go-to-definition, inline errors, refactoring and preview.

CAP ABAP BTP/BAIP UI5

Encryption and signing

Encrypting, decrypting and signing data from application code: a document wrapped for one recipient, a payload signed so its origin can be checked, a value enciphered with a key both sides hold.

ABAP BTP/BAIP

Error handling

Turning a failure into a response a client can act on — protocol-correct error payloads, correlation, and a boundary between internal detail and what a caller sees.

CAP ABAP

Event Mesh

Emitting and consuming business events across systems through brokers, including subscriptions and mapping application events to broker topics.

CAP BTP/BAIP ABAP

Extensibility

Letting a customer change delivered behaviour without modifying it — key-user fields and logic, developer extensions, and the released extension points that make either safe across an upgrade.

ABAP

Feature toggles

Turning behaviour on and off per tenant or per user at runtime, without redeploying, and knowing which toggles are live.

CAP BTP/BAIP ABAP

Finding a transaction code

Getting from a task to the code that starts it, and keeping the codes you use within reach.

ABAP

Fiori annotations

Describing a service so a Fiori client can render it without hand-written UI code — titles, value helps, hierarchies and visibility expressed as model annotations rather than screen logic.

CAP UI5 ABAP

Frontend boundary

Connecting a separately hosted frontend to an application service: authentication, routing, access to backend systems, user identity propagation and tenant isolation across the hosting boundary.

CAP

Frontend performance

Finding why a browser UI is slow to start or to respond, and what to change: how many requests it sends and whether they block each other, how large its bundles are, and which OData round trips it waits on.

UI5

Generative UI

Putting an interface inside an agent conversation: a tool result or an agent's reply shown as controls a person can work in, where text would have been.

UI5 CAP

Generators

Getting from nothing to a project that runs, and from a project that runs to one that has the piece you just decided you need.

CAP ABAP UI5

Graph, spatial and document data

Storing and querying data that is not plain rows, such as a network of relationships, a geometry or a JSON document, in the database that already holds the rows instead of in a separate store per model.

BTP/BAIP

GraphQL

Serving the same model over GraphQL instead of OData — one endpoint, the client naming the fields it wants, for consumers who expect that shape rather than an OData one.

CAP

Health checks

Readiness and liveness that mean something for a service — is the database reachable, are bindings resolved, is the message broker connected — rather than merely whether the process is up.

CAP

Health data interoperability

Exchanging health-related data using the HL7 FHIR standard: FHIR resources profiled and stored for a project's own business and localization needs, reached over REST APIs, and connected to an external system through FHIR-specification messaging rather than a bespoke integration built per source.

BTP/BAIP

HTTP clients

Calling an HTTP API outside the system from application code, with the request, the credential and the response handled by a client each time the call is made.

ABAP

IDE provisioning

Getting the IDE onto a developer's machine with the required plugins already in it, at a version the team can name.

ABAP

Identity provisioning

Getting users, groups and role assignments into every system that needs them, and out again when a person leaves, through provisioning jobs or SCIM APIs.

BTP/BAIP

Importing and exporting table data

Getting a file somebody supplies, a spreadsheet, a CSV or a JSON dump, into tables with its columns mapped and its values checked, and getting table content back out as a file.

ABAP UI5 CAP

In-app guidance

Explaining an application from inside it — guided tours, hotspots and contextual help shown next to the screen a user is on, rather than in a separate manual.

CAP

Input validation

Rejecting bad input before it reaches the database.

CAP ABAP UI5

Integrated frontend dev server

Serving a frontend and its backend services together during development, so they can be reached through one local origin.

CAP UI5

Integration flows

Moving and transforming messages between systems in middleware instead of in application code: an integration flow with its adapters and mappings, and the runtime it executes on.

BTP/BAIP

Integration scenario setup

Walking through the technical configuration that connects systems — cloud to on-premise, or one cloud solution to another — as a guided, role-assigned checklist rather than a configuration guide followed by hand.

BTP/BAIP

Job scheduling

Running something later, or on a cadence, without keeping a process alive to do it — a nightly job, a retry in an hour, a report on the first of the month — and knowing afterwards whether it ran.

BTP/BAIP CAP ABAP

Key-user adaptation

Changing a delivered app without modifying it — moving, hiding and adding elements as a layered set of changes that survive an upgrade.

UI5 ABAP BTP/BAIP

Knowing the maintenance status of a release

Knowing whether a release a solution runs on is still maintained, and until when: which versions get fixes, which get critical fixes only, and when maintenance ends.

ABAP CAP UI5

Launchpad and site content

Getting apps, cards, pages and workspaces in front of users in an application launchpad or portal, including content providers, content packages and access roles.

BTP/BAIP UI5

Launchpad plugins

Extending an application launchpad’s shell rather than an individual app: adding header buttons, user-menu entries, frame areas or background behaviour shared across the apps it hosts.

UI5 ABAP BTP/BAIP

Linting

Catching in the editor what would otherwise be caught at deploy time, or not at all — problems in source code and models and in the project's configuration, found by rules rather than by review.

CAP UI5

LLM integration

Calling a language model from application code with the tenant, destination and credential handling already solved instead using an SDK call with a hand-rolled key.

CAP UI5 BTP/BAIP ABAP

Loading a warehouse

Getting data into an analytical store and keeping it current — connections to source systems, replication and the other integration tasks, import jobs and their lifecycle, and the monitoring that tells you a load failed before a report does.

BTP/BAIP ABAP

Local development

Running the whole stack on a laptop against real bindings — the service, the UI and the routing in front of it — without deploying to see a change.

CAP ABAP

Localization

Serving labels, messages and translated content per user locale, including translatable model elements and per-tenant text overrides.

CAP ABAP BTP/BAIP UI5

Location services

Putting a place on business data from a location provider: an address turned into coordinates or corrected, a base map to draw on, and a route with its distance and duration between two or more points.

BTP/BAIP CAP

Logging

Seeing what a running service did, in a form something can read afterwards — levels, a formatter that suits a laptop and one that suits a log service.

CAP BTP/BAIP ABAP UI5

Low-code apps

Building an application by arranging UI components, logic flows and formulas in a visual editor instead of writing its code, backend included.

BTP/BAIP

Maintaining table entries

Editing the rows of a data or configuration table through a generic or generated screen, with value helps, checks and a managed change package, so that no maintenance application is written per table.

ABAP

Malware scanning

Checking a file somebody uploaded before anyone else can download it — where the scan runs, what happens to the file meanwhile, and who is told when it fails.

BTP/BAIP CAP

Metadata publishing

Describing a service to something other than a human — service metadata for clients, and machine-readable descriptions for registries and discovery.

CAP

Mobile apps

Building a native iOS or Android app over business data: onboarding, offline sync against an OData service, device features, and the client that runs on the phone.

BTP/BAIP

Model visualisation

Turning a data or code model into a readable picture of its entities, classes, fields and relationships, so a reader can understand the shape of a domain without opening every source file.

CAP ABAP

Multitenancy

Serving many tenants from one deployment — onboarding, tenant-isolated data, per-tenant schema deployment and the operational tooling around it.

CAP BTP/BAIP

Native SAP HANA artifacts

Using native SAP HANA database objects alongside an application’s generated data model, including objects and database features the modelling layer cannot express.

CAP

Notifications

Telling a person something happened when they are not looking at the screen — a notification in the launchpad, an email, a message somewhere they already are.

CAP ABAP

Object storage

Storing application files as objects in a bucket or container backed by a cloud storage service.

BTP/BAIP

OData

Exposing data and operations through OData, including the service model, metadata and protocol versions clients require.

CAP ABAP

OpenAPI

Handing a description of the service to clients and tools — an API portal, a code generator, a partner who wants a contract before they write anything.

CAP ABAP BTP/BAIP

Operations automation

Acting on a running landscape without someone at the console: an alert routed to where a person or a system will pick it up, and a command that troubleshoots or remediates when it arrives.

BTP/BAIP

Pagination and streaming

Returning results a client can consume without loading everything — server-driven paging, and streaming large binaries rather than buffering them.

CAP

Parallel processing

Splitting one run's work across several work processes so that it finishes sooner, and collecting what each part returned before the run goes on.

ABAP

Platform migration

Moving an application, integration or database from one platform to another: assessing what exists, converting what tooling supports, and adapting what cannot carry over.

BTP/BAIP CAP

Plugin authoring

Writing a package that extends a framework or runtime rather than an application that uses it — a reusable extension loaded by its host, and the question you arrive at once solving a problem twice makes you want to solve it once for everyone.

CAP

POD plugins

Extending SAP Digital Manufacturing's Production Operator Dashboard with plugins of your own: a view, a panel or an action that runs inside the operator's POD, packaged as an extension the product loads.

SAP Digital Manufacturing

Predictive models

Training, deploying and calling a model that predicts a value from tabular business data: a classification, a regression, a forecast.

BTP/BAIP

Process automation

Modelling and running a business process: the process flow, the forms people fill in, decision tables, bots for repetitive steps, and dashboards over the instances that run.

BTP/BAIP

Prompt management

Keeping the prompts an application sends to a model as templates with placeholders, stored and versioned apart from the code that calls them, so a change of wording is not a deployment.

BTP/BAIP CAP

Query profiling

Finding which application queries are slow and why, at the application query layer rather than in database traces — attributing cost back to the service, entity and handler that caused it.

CAP

Rate limiting

Capping how many requests a service will accept per tenant or per caller, so one consumer cannot exhaust a shared deployment, whether enforced by a policy in front of the application or inside its own process.

CAP BTP/BAIP

Reference apps

A whole application to read rather than a snippet to copy — somewhere to see how the pieces sit together once there are more than three of them.

CAP ABAP

Responsibility assignment

Resolving who owns a business process, document or work item — a person or a team, from a condition-based rule or from a lookup mapped to an external system — and notifying them, so a framework can ask rather than hard-code an agent.

BTP/BAIP

Retrieval-augmented generation

Grounding a model's answer in data retrieved at question time: text split into chunks, each chunk embedded as a vector, and the chunks nearest to the question placed into the prompt.

CAP ABAP BTP/BAIP

RFC connectivity

Calling ABAP function modules from outside the system over RFC, with destinations and connection pooling handled rather than hand-wired on the calling side.

CAP BTP/BAIP ABAP

Routing and navigation

Turning a URL hash into a view, and a view change back into a URL — so a deep link, a browser back button and a refresh all land where the user expects in a single-page app.

UI5

SAP GUI screens and lists

Building screens, lists and interactive controls for the SAP GUI.

ABAP

Schema evolution

Getting a model change into a database that already holds data, in every tenant, without losing any of it.

CAP

Free-text search across an entity and its compositions, pushed into the database rather than filtered in the service.

CAP ABAP

Searching code in a system

Finding where a string, pattern or name occurs across source code and development objects held in a system.

ABAP

Secrets rotation

Rotating credentials a running service depends on — service keys, destination credentials, API tokens — without downtime and without redeploying.

BTP/BAIP CAP

Seed data

Getting realistic data into a service so it can be developed and demonstrated — initial data, per-tenant content, and believable volumes for testing.

CAP ABAP UI5

Serialisation

Turning typed in-memory data into a text or binary format such as JSON, CSV or protobuf and reading it back, including the mapping of names and types the language does not do for you.

ABAP

Serve your application over MCP

Exposing selected application data and business operations to an AI agent through the Model Context Protocol.

CAP BTP/BAIP ABAP

Server-side rendering

Rendering a UI on the server before it reaches the browser — first paint without waiting for a client framework to boot, and markup a crawler can read.

CAP UI5

Service composition

Building one solution out of parts other projects published: a reuse package brings its models, code, initial data and texts into your project through npm or Maven, you serve what you reference and extend what you import, and the same modules deploy as one application or as several on a shared database.

CAP

Service integration

Using a service that runs somewhere else as if it were one of your own: its API imported into the model, a proxy that turns a local query into the remote protocol, and a mock that stands in for it on a laptop.

CAP

Soft delete

Deleting a record without removing it — flagging the row, recording who deleted it and when, and keeping it out of reads.

CAP

Source control

Keeping source code and development objects in version control, comparing their revisions, and moving them between development environments.

ABAP

Static analysis

Catching problems in code before it runs: naming, obsolete statements, security findings, and compatibility with a target environment.

ABAP

Statistical analysis

Describing a set of values with numbers: spread, quantiles, correlation, the shape of the distribution they came from, and drawing a sample from a named one.

ABAP

Status flows

Declaring in the model which status transitions an entity may make, so the runtime rejects a transition nobody declared and sets the status itself when the bound action runs, instead of a check written by hand in every handler.

CAP

Task and approval UIs

The screen a person approves something on — a workflow or process task rendered as a form, embedded in an inbox that supplies its context.

BTP/BAIP UI5

Telemetry

Seeing what a running service did — traces across handlers and database calls, metrics, and correlation that survives an async boundary.

CAP ABAP BTP/BAIP

Temporal data

Keeping every version of a record that was valid for a period, and reading the one that held at a given moment — the assignment somebody had on the first of March, not the one they have now — without the application filtering time slices by hand.

CAP

Tenant extensibility

Letting a customer extend the model of a running SaaS application with extra fields and entities per tenant, without forking the application, as distinct from extending the application's code for every customer at once.

CAP

Testing

Proving the service still does what it did — against the model and the handlers, without a deployed system and without a database somebody has to keep clean.

CAP BTP/BAIP SAP Digital Manufacturing

Theming

Applying a consistent visual identity across every control, including the parameters an app may read and the custom themes an organisation may build.

UI5

Third-party connectors

Reaching a non-SAP cloud application through a prebuilt connector instead of coding against that vendor's API: the connector holds the credentials and presents the application's resources in one common REST form.

BTP/BAIP

Tool governance

Controlling what an agent may call, with which authorisations, and leaving an audit trail of what it did.

CAP ABAP BTP/BAIP

Touch operation

Operating an app with a finger, a stylus or a gloved hand on a tablet, kiosk or shop-floor terminal: targets large enough to hit, and input that does not assume a hardware keyboard.

UI5

Trading partner agreements

Keeping track of who business documents are exchanged with and what is set up with each partner: a profile per partner with its contact person, identifiers, communication protocol and B2B standards, an agreement per partner, and one generic flow parameterised from them in place of a flow per partner.

BTP/BAIP

Transaction management

Deciding where a unit of work begins and ends, and what travels with it: the database transaction that commits or rolls back around a request, the user, tenant and locale that every nested call inherits, and the work that must run outside the request in a transaction of its own.

CAP

Transactional model

How a business object's behaviour is defined and who owns the transaction — the choice that shapes everything downstream in an application.

ABAP

TypeScript patterns

How an application is arranged once it is written in TypeScript — where handlers live, what registers them, and how business logic is kept apart from persistence.

CAP

TypeScript support

Writing apps and libraries in TypeScript — the type definitions, the module syntax the loader expects, and the build step that gets from one to the other.

UI5

Typing

Making the model visible to the compiler — generated types for entities and events so a rename breaks the build rather than production.

CAP

UI written in ABAP

Producing a web user interface from ABAP code, with the application’s backend language also defining what the user sees and how it behaves.

ABAP

UI5 testing

Proving a UI still works — unit tests over controllers and formatters, integration tests that drive real controls, and end-to-end runs against a served app.

UI5

Unit testing

Testing application logic without a running business process — and the test doubles that make dependencies on the database and on framework services tractable.

ABAP

Value normalisation

Making stored values consistent regardless of how they were typed — trimming the padding, fixing the case — declared on the model rather than repeated in every handler that writes.

CAP

Vulnerability scanning

Finding known vulnerabilities in the open-source components an application depends on, in the project's dependency tree before it is deployed and in the application once it runs, and following each one until it is fixed.

BTP/BAIP CAP UI5

Web Components interop

Using standards-based custom elements inside an app, and the question of which control set an app should be built from at all, two concerns that are often answered as one.

UI5

WebSocket

Pushing to a browser that already has the page open, rather than making it ask again — the half of a UI that polling imitates badly.

CAP

Workflow integration

Driving an external workflow or automation engine from an application and reacting to what it emits — triggering runs transactionally and importing the engine’s shape as a typed model.

CAP

XML payloads

Accepting and returning XML on a service, or sending it to one, for a counterpart that cannot speak JSON — usually a B2B partner or a system older than the extension in front of it.

CAP ABAP