# onedevatlas

> A curated, connected map of the SAP development ecosystem — CAP, UI5, ABAP and BTP, with product doors for SAP Commerce and SAP SuccessFactors under More: capabilities, the artifacts that provide them, and the writing that explains them. Readings are mechanical and prose is authored; the two are reported separately and never combined into a score.

Every claim in the data is dated and sourced. Each capability, artifact, content and external entry carries `drafted_with_ai`; items below whose prose was drafted with AI are marked so. Origin (SAP-official, community organisation, independent) is recorded as a facet and is not an input to any reading.

## Data

- [Full text](https://onedevatlas.dev/llms-full.txt): every capability, artifact and piece of content with its prose and readings, in plain text
- [The whole graph](https://onedevatlas.dev/graph.json): every node and every edge as JSON
- [Entity JSON](https://onedevatlas.dev/capabilities/caching.json): every entity page has a JSON file beside it at the same path plus `.json` — /capabilities/<id>.json, /artifacts/<id>.json, /content/<id>.json, /actors/<id>.json, /externals/<id>.json
- [MCP discovery](https://onedevatlas.dev/.well-known/mcp.json): a stateless streamable-HTTP MCP endpoint exists at https://onedevatlas.dev/mcp

## CAP

- [CAP map](https://onedevatlas.dev/cap)
- [Reference architectures](https://onedevatlas.dev/cap/browse?show=readings&ctype=reference-architecture): 12 published designs behind this door, 7 with their parts read into the graph

### AI & Agents

- [Agent access to your code](https://onedevatlas.dev/capabilities/agent-code-access): 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. In file-based environments that works out of the box; complex systems need dedicated access capabilities. Whatever the environment, the agent also needs project- and framework-specific context, so it understands the thing in front of it rather than guessing from what it remembers of its training data. The transport is incidental: an MCP server, a language server or a CLI answer the same question, and what differs between them is how much of the real thing the agent can see. Distinct from MCP servers, which is a protocol adapter on your own running service, and from agent guidance, which is knowledge handed over as files rather than read from the thing itself. Also in ABAP, UI5, BTP/BAIP. (drafted with AI)
- [Agent evals](https://onedevatlas.dev/capabilities/agent-evals): Knowing whether an AI feature still behaves after a model, prompt or schema change. Regression testing for non-deterministic output, against fixtures that reflect real business data. Also in BTP/BAIP, ABAP. (drafted with AI)
- [Agent guidance](https://onedevatlas.dev/capabilities/agent-guidance): Packaged knowledge you hand a coding agent so it gets a framework right unprompted — skills, rule files, instruction packs. Distinct from agent tooling, which is about building agentic features into your application, and from agent access to your code, where the agent reads the real project instead of being handed a file about it. Also in UI5, BTP/BAIP, ABAP, SAP Commerce. (drafted with AI)
- [Agent tooling](https://onedevatlas.dev/capabilities/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. Distinct from MCP servers, which expose an application to somebody else's agent, and from agent guidance, which is knowledge handed to a coding agent. Also in BTP/BAIP. (drafted with AI)
- [LLM integration](https://onedevatlas.dev/capabilities/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. Also in UI5, BTP/BAIP, ABAP. (drafted with AI)
- [Retrieval-augmented generation](https://onedevatlas.dev/capabilities/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. Semantic search is the same retrieval with a person reading the matches, and fine-tuning changes the model's weights, not its input. Also in ABAP, BTP/BAIP. (drafted with AI)
- [Tool governance](https://onedevatlas.dev/capabilities/tool-governance): Controlling what an agent may call, with which authorisations, and leaving an audit trail of what it did. The authorisation question that MCP exposure raises but does not answer. Also in ABAP, BTP/BAIP. (drafted with AI)

### Data & Persistence

- [Analytical queries](https://onedevatlas.dev/capabilities/analytical-queries): Grouped, aggregated and filtered reads for analytical clients, answered by the database rather than in application memory. This concerns the queries a chart or report sends, while analytic modelling defines the measures and dimensions they read. (drafted with AI)
- [Attachments](https://onedevatlas.dev/capabilities/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. Also in UI5, ABAP, BTP/BAIP. (drafted with AI)
- [Caching](https://onedevatlas.dev/capabilities/caching): Holding the result of an expensive read so the next one is cheap. This spans four different things people call caching — HTTP response caching, query result caching, remote service response caching, and application-level memoisation. They are not interchangeable, and picking the wrong one is the usual cause of stale-data bugs in multitenant apps. Also in BTP/BAIP, ABAP. (drafted with AI)
- [Concurrency control](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Data federation](https://onedevatlas.dev/capabilities/replication): 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. Three different answers to one question, and the choice is about how stale you can afford to be. Also in BTP/BAIP. (drafted with AI)
- [Data modelling](https://onedevatlas.dev/capabilities/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. Also in ABAP. (drafted with AI)
- [Database connectors](https://onedevatlas.dev/capabilities/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. Changing an existing schema belongs to schema evolution. Also in BTP/BAIP, ABAP. (drafted with AI)
- [Native SAP HANA artifacts](https://onedevatlas.dev/capabilities/hana-native-artifacts): Using native SAP HANA database objects alongside an application’s generated data model, including objects and database features the modelling layer cannot express. Choosing a database is database connectors; changing an existing schema is schema evolution. (drafted with AI)
- [Query profiling](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Schema evolution](https://onedevatlas.dev/capabilities/schema-evolution): Getting a model change into a database that already holds data, in every tenant, without losing any of it. Generating the initial schema and migrating one that already holds data are often treated as the same step. (drafted with AI)
- [Search](https://onedevatlas.dev/capabilities/search): Free-text search across an entity and its compositions, pushed into the database rather than filtered in the service. Declared search, database similarity search and filtering in application code are often lumped together. Also in ABAP. (drafted with AI)
- [Soft delete](https://onedevatlas.dev/capabilities/soft-delete): Deleting a record without removing it — flagging the row, recording who deleted it and when, and keeping it out of reads. The question underneath is what DELETE should mean to a client that cannot tell the difference, and what happens to a composition tree when its root is flagged. (drafted with AI)
- [Temporal data](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Transaction management](https://onedevatlas.dev/capabilities/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. Distinct from concurrency control, which is two writers on one record, and from async processing, which is work that survives the commit. (drafted with AI)
- [Value normalisation](https://onedevatlas.dev/capabilities/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. (drafted with AI)

### Developer Experience

- [Debugging](https://onedevatlas.dev/capabilities/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. Also in ABAP. (drafted with AI)
- [Editor support](https://onedevatlas.dev/capabilities/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. Also in ABAP, BTP/BAIP, UI5. (drafted with AI)
- [Generators](https://onedevatlas.dev/capabilities/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. Two different moments: the first is a one-time decision about layout, the second recurs for the life of the project. Also in ABAP, UI5. (drafted with AI)
- [Linting](https://onedevatlas.dev/capabilities/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. Also in UI5. (drafted with AI)
- [Local development](https://onedevatlas.dev/capabilities/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. Also in ABAP. (drafted with AI)
- [Model visualisation](https://onedevatlas.dev/capabilities/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. Also in ABAP. (drafted with AI)
- [Plugin authoring](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Seed data](https://onedevatlas.dev/capabilities/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. Also in ABAP, UI5. (drafted with AI)
- [Testing](https://onedevatlas.dev/capabilities/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. Also in BTP/BAIP, SAP Digital Manufacturing. (drafted with AI)
- [TypeScript patterns](https://onedevatlas.dev/capabilities/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. Distinct from typing, which is about the model being visible to the compiler; this is about the shape of the code around it. (drafted with AI)
- [Typing](https://onedevatlas.dev/capabilities/typing): Making the model visible to the compiler — generated types for entities and events so a rename breaks the build rather than production. (drafted with AI)

### Integration & Messaging

- [Async processing](https://onedevatlas.dev/capabilities/async-processing): Doing work outside the request that triggered it, with a guarantee that it eventually happens — deferred jobs, retries, and periodic work. Distinct from messaging, which is about telling other systems. Also in ABAP, BTP/BAIP. (drafted with AI)
- [Destinations](https://onedevatlas.dev/capabilities/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. The destination is the indirection, and the reason an endpoint can move without a redeploy. Also in BTP/BAIP, UI5. (drafted with AI)
- [Document output](https://onedevatlas.dev/capabilities/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. Also in ABAP, BTP/BAIP. (drafted with AI)
- [Event Mesh](https://onedevatlas.dev/capabilities/event-mesh): Emitting and consuming business events across systems through brokers, including subscriptions and mapping application events to broker topics. Work that must survive a request, including deferred processing and retries, belongs to async processing. Also in BTP/BAIP, ABAP. (drafted with AI)
- [Notifications](https://onedevatlas.dev/capabilities/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. Also in ABAP. (drafted with AI)
- [RFC connectivity](https://onedevatlas.dev/capabilities/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. Also in BTP/BAIP, ABAP. (drafted with AI)
- [Service composition](https://onedevatlas.dev/capabilities/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. Distinct from service integration, which reaches a service that stays deployed elsewhere, and from tenant extensibility, which is a subscriber extending a running SaaS. (drafted with AI)
- [Service integration](https://onedevatlas.dev/capabilities/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. Distinct from destinations, which is how the address and the credentials are found, and from replication, which is holding the data locally. (drafted with AI)

### Learning & Reference

- [Documentation](https://onedevatlas.dev/capabilities/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. Also in UI5, BTP/BAIP, ABAP. (drafted with AI)
- [Reference apps](https://onedevatlas.dev/capabilities/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. Also in ABAP. (drafted with AI)

### Operations & Runtime

- [Configuration](https://onedevatlas.dev/capabilities/configuration): Per-environment settings without per-environment code — profiles, layered configuration, and bindings resolved from the platform at start-up. Also in ABAP. (drafted with AI)
- [Deployment](https://onedevatlas.dev/capabilities/deployment): Getting an application onto a runtime and keeping it there: build descriptors, deployment topology, service bindings and lifecycle operations. The target runtime determines how the application is packaged and configured. Also in BTP/BAIP. (drafted with AI)
- [Deployment and operator](https://onedevatlas.dev/capabilities/deployment-operator): Automating the build and deployment of a project with multiple modules: generating deployment descriptors and coordinating build, migration, deployment and validation commands. Deployment describes the target runtime and lifecycle; this concerns the tooling that drives those steps. Also in BTP/BAIP. (drafted with AI)
- [Feature toggles](https://onedevatlas.dev/capabilities/feature-toggles): Turning behaviour on and off per tenant or per user at runtime, without redeploying, and knowing which toggles are live. System-level switches for delivered objects and runtime flags for unfinished features share the name. Also in BTP/BAIP, ABAP. (drafted with AI)
- [Health checks](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Logging](https://onedevatlas.dev/capabilities/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. Also in BTP/BAIP, ABAP, UI5. (drafted with AI)
- [Multitenancy](https://onedevatlas.dev/capabilities/multitenancy): Serving many tenants from one deployment — onboarding, tenant-isolated data, per-tenant schema deployment and the operational tooling around it. It is decided once, before anything is built, and narrows the artifacts in almost every capability downstream: most sharply in caching and anything else holding state in process. Also in BTP/BAIP. (drafted with AI)
- [Telemetry](https://onedevatlas.dev/capabilities/telemetry): Seeing what a running service did — traces across handlers and database calls, metrics, and correlation that survives an async boundary. Also in ABAP, BTP/BAIP. (drafted with AI)
- [Tenant extensibility](https://onedevatlas.dev/capabilities/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. (drafted with AI)

### Process & Workflow

- [Status flows](https://onedevatlas.dev/capabilities/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. Not input validation: that checks a value, this checks a transition. Not workflow integration: that drives an external engine, and this stays inside the model. (drafted with AI)
- [Workflow integration](https://onedevatlas.dev/capabilities/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. (drafted with AI)

### Protocols & APIs

- [Analytical models](https://onedevatlas.dev/capabilities/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. Separate from Analytical queries, which is the query shape an OData client issues against the same service: here the question is what the service declares itself to be. (drafted with AI)
- [Error handling](https://onedevatlas.dev/capabilities/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. Also in ABAP. (drafted with AI)
- [GraphQL](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Metadata publishing](https://onedevatlas.dev/capabilities/metadata-publishing): Describing a service to something other than a human — service metadata for clients, and machine-readable descriptions for registries and discovery. (drafted with AI)
- [OData](https://onedevatlas.dev/capabilities/odata): Exposing data and operations through OData, including the service model, metadata and protocol versions clients require. Version differences affect which clients can consume a service and which query features they can use. Also in ABAP. (drafted with AI)
- [OpenAPI](https://onedevatlas.dev/capabilities/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. Also in ABAP, BTP/BAIP. (drafted with AI)
- [Pagination and streaming](https://onedevatlas.dev/capabilities/pagination-and-streaming): Returning results a client can consume without loading everything — server-driven paging, and streaming large binaries rather than buffering them. (drafted with AI)
- [Serve your application over MCP](https://onedevatlas.dev/capabilities/mcp-servers): Exposing selected application data and business operations to an AI agent through the Model Context Protocol. An application may also integrate remote services through service integration, connecting its exposed contract with agent access to your systems. Development assistance belongs to agent access to your code. Also in BTP/BAIP, ABAP. (drafted with AI)
- [WebSocket](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [XML payloads](https://onedevatlas.dev/capabilities/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. Also in ABAP. (drafted with AI)

### Security & Compliance

- [Audit logging](https://onedevatlas.dev/capabilities/audit-logging): Recording who touched personal or sensitive data, in a form an auditor accepts, without hand-writing it in every handler. It is often confused with application logging, which records what the code did rather than who accessed what. Also in BTP/BAIP. (drafted with AI)
- [Authentication](https://onedevatlas.dev/capabilities/authentication): Establishing who is calling: validating credentials or tokens, resolving the user, and making that identity available to the application. Authorization decides what that identity may do; identity provisioning manages its lifecycle across systems. Also in BTP/BAIP, ABAP, UI5. (drafted with AI)
- [Authorization](https://onedevatlas.dev/capabilities/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. Also in BTP/BAIP, ABAP. (drafted with AI)
- [Change tracking](https://onedevatlas.dev/capabilities/change-tracking): Keeping a readable history of what changed on a record, who changed it and when — as business history rather than database journalling. Also in ABAP. (drafted with AI)
- [Data privacy](https://onedevatlas.dev/capabilities/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. Also in ABAP, BTP/BAIP. (drafted with AI)
- [Input validation](https://onedevatlas.dev/capabilities/input-validation): Rejecting bad input before it reaches the database. While this can be done manually inside a handler, there are solutions in place to derive type, range, enum and mandatory checks from the model definitions. Also in ABAP, UI5. (drafted with AI)
- [Rate limiting](https://onedevatlas.dev/capabilities/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. Also in BTP/BAIP. (drafted with AI)

### UI & Frontend Bridge

- [Draft handling](https://onedevatlas.dev/capabilities/draft-handling): Letting a user edit a record over several requests before it becomes real — saving unfinished changes, locking, and activating a completed draft. (drafted with AI)
- [Fiori annotations](https://onedevatlas.dev/capabilities/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. Also in UI5, ABAP. (drafted with AI)
- [Frontend boundary](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [In-app guidance](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Integrated frontend dev server](https://onedevatlas.dev/capabilities/ui5-dev-server): Serving a frontend and its backend services together during development, so they can be reached through one local origin. Serving prebuilt files and integrating a frontend toolchain that assembles resources on demand are different requirements. Also in UI5. (drafted with AI)
- [Localization](https://onedevatlas.dev/capabilities/localization): Serving labels, messages and translated content per user locale, including translatable model elements and per-tenant text overrides. Also in ABAP, BTP/BAIP, UI5. (drafted with AI)
- [Server-side rendering](https://onedevatlas.dev/capabilities/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. Also in UI5. (drafted with AI)

## UI5

- [UI5 map](https://onedevatlas.dev/ui5)
- Status: Early. The atlas already contains capabilities and artifacts but there is still a lot of the ecosystem to explore.
- [Reference architectures](https://onedevatlas.dev/ui5/browse?show=readings&ctype=reference-architecture): 2 published designs behind this door, 1 with their parts read into the graph

### AI & Agents

- [Generative UI](https://onedevatlas.dev/capabilities/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. Two things go by the name. A prebuilt web UI that an MCP tool points to and the host renders in a sandboxed iframe, which the MCP Apps extension specifies, is selected by the model and not generated by it; a user interface rendered from a stream of JSON objects the agent sends, which the A2UI specification describes, is. Generating an application's source at design time is generators. Also in CAP. (drafted with AI)

### Developer Experience

- [Build and dev-server tooling](https://onedevatlas.dev/capabilities/ui5-build-tooling): Serving an app locally and building it for deployment — proxying a backend, transpiling, bundling, and shaping the result for whatever will host it. (drafted with AI)
- [TypeScript support](https://onedevatlas.dev/capabilities/ui5-typescript): 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. (drafted with AI)
- [UI5 testing](https://onedevatlas.dev/capabilities/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. (drafted with AI)

### UI & Frontend Bridge

- [Accessibility](https://onedevatlas.dev/capabilities/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. Target size for a finger is touch operation. (drafted with AI)
- [Custom controls and libraries](https://onedevatlas.dev/capabilities/ui5-custom-controls): 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. Distinct from Web Components interop, which brings in standard custom elements, and from generators, which scaffold a control project rather than being one. (drafted with AI)
- [Data binding](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Frontend performance](https://onedevatlas.dev/capabilities/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. Distinct from query profiling, which starts at the service and the database rather than at the browser's network log. (drafted with AI)
- [Key-user adaptation](https://onedevatlas.dev/capabilities/ui5-flexibility): Changing a delivered app without modifying it — moving, hiding and adding elements as a layered set of changes that survive an upgrade. Also in ABAP, BTP/BAIP. (drafted with AI)
- [Launchpad plugins](https://onedevatlas.dev/capabilities/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. A development sandbox for launching an app is a separate concern. Also in ABAP, BTP/BAIP. (drafted with AI)
- [Routing and navigation](https://onedevatlas.dev/capabilities/ui5-routing): 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. (drafted with AI)
- [Theming](https://onedevatlas.dev/capabilities/ui5-theming): Applying a consistent visual identity across every control, including the parameters an app may read and the custom themes an organisation may build. (drafted with AI)
- [Touch operation](https://onedevatlas.dev/capabilities/ui5-touch-uis): 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. Distinct from responsive layout, which is about the width of the screen rather than what touches it. (drafted with AI)
- [Web Components interop](https://onedevatlas.dev/capabilities/ui5-web-components): 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. (drafted with AI)

## ABAP

- [ABAP map](https://onedevatlas.dev/abap)
- Status: Early. The atlas already contains capabilities and artifacts but there is still a lot of the ecosystem to explore.
- [Reference architectures](https://onedevatlas.dev/abap/browse?show=readings&ctype=reference-architecture): 3 published designs behind this door, 1 with their parts read into the graph

### Data & Persistence

- [Importing and exporting table data](https://onedevatlas.dev/capabilities/data-import-export): 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. Data shipped with an application for development and demonstration is seed data. Also in UI5, CAP. (drafted with AI)
- [Maintaining table entries](https://onedevatlas.dev/capabilities/table-maintenance): 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. Looking at what a table holds is browsing table data, even where one transaction does both. (drafted with AI)
- [Statistical analysis](https://onedevatlas.dev/capabilities/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. Computed in the application over data it already holds, which is what separates it from analytical queries, where a service answers the grouped read a chart sends, and from predictive models, which train and serve something that predicts a value. (drafted with AI)
- [Transactional model](https://onedevatlas.dev/capabilities/abap-transactional-model): How a business object's behaviour is defined and who owns the transaction — the choice that shapes everything downstream in an application. (drafted with AI)

### Developer Experience

- [Browsing table data](https://onedevatlas.dev/capabilities/abap-data-browsing): 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. Editing configuration records through maintenance screens is a different job, even where the same transaction does both. (drafted with AI)
- [Calling a service by hand](https://onedevatlas.dev/capabilities/abap-service-testing): 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. Distinct from unit testing, which proves logic in code and keeps the proof. (drafted with AI)
- [Code formatting](https://onedevatlas.dev/capabilities/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. Distinct from static analysis, which says what is wrong and leaves the source where it is. (drafted with AI)
- [Code metrics](https://onedevatlas.dev/capabilities/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. Raising findings against a rule is static analysis. (drafted with AI)
- [Code review](https://onedevatlas.dev/capabilities/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. Comparing two versions of one object is where it starts; the review is the record kept of the decision. (drafted with AI)
- [Dependency injection](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Driving the SAP GUI](https://onedevatlas.dev/capabilities/gui-automation): Operating the SAP GUI programmatically to perform tasks or test interactions through the actual screen. Agent access to your code works with development objects instead of the user interface. (drafted with AI)
- [Finding a transaction code](https://onedevatlas.dev/capabilities/transaction-code-lookup): Getting from a task to the code that starts it, and keeping the codes you use within reach. Looking at what a system holds once you are inside one is browsing table data, and driving its screens as a program is GUI automation. (drafted with AI)
- [IDE provisioning](https://onedevatlas.dev/capabilities/ide-provisioning): Getting the IDE onto a developer's machine with the required plugins already in it, at a version the team can name. Distinct from editor support, which is what the editor does once it is there: this is the download, the update site, the install and how the result reaches machines a developer does not administer. (drafted with AI)
- [Searching code in a system](https://onedevatlas.dev/capabilities/code-search): Finding where a string, pattern or name occurs across source code and development objects held in a system. Raising findings against rules is static analysis; reading an individual change is code review. (drafted with AI)
- [Source control](https://onedevatlas.dev/capabilities/abap-source-control): Keeping source code and development objects in version control, comparing their revisions, and moving them between development environments. Managed delivery of changes belongs to transport management. (drafted with AI)
- [Static analysis](https://onedevatlas.dev/capabilities/abap-static-analysis): Catching problems in code before it runs: naming, obsolete statements, security findings, and compatibility with a target environment. Style linting, security scanning and cloud-readiness checks are often treated as one concern. (drafted with AI)
- [Unit testing](https://onedevatlas.dev/capabilities/abap-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. (drafted with AI)

### Learning & Reference

- [Clean code conventions](https://onedevatlas.dev/capabilities/abap-clean-code): 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. (drafted with AI)

### Operations & Runtime

- [ABAP Cloud readiness](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Change promotion](https://onedevatlas.dev/capabilities/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. A CI/CD pipeline builds and tests on each source change, deployment puts a build onto its runtime, and getting source into git is source control. Also in BTP/BAIP, CAP, UI5. (drafted with AI)
- [Extensibility](https://onedevatlas.dev/capabilities/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. (drafted with AI)
- [Knowing the maintenance status of a release](https://onedevatlas.dev/capabilities/product-maintenance-status): 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. Upgrading to a newer release once that is known is a different job. Also in CAP, UI5. (drafted with AI)
- [Parallel processing](https://onedevatlas.dev/capabilities/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. Async processing is the neighbouring concern: work deferred past the request with a guarantee that it eventually happens, where parallel processing is throughput inside a run that waits for its results. (drafted with AI)

### Protocols & APIs

- [HTTP clients](https://onedevatlas.dev/capabilities/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. Serving HTTP is the other direction, and where the address and the credential are kept is destinations. (drafted with AI)
- [Serialisation](https://onedevatlas.dev/capabilities/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. The protocol that carries the payload is a separate concern: an HTTP or OData client moves the bytes, and serialisation decides what they say. (drafted with AI)

### Security & Compliance

- [Certificate management](https://onedevatlas.dev/capabilities/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. Storing and rotating passwords and keys an application reads is secrets rotation. Also in BTP/BAIP. (drafted with AI)
- [Encryption and signing](https://onedevatlas.dev/capabilities/encryption): 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. Encryption of a connection, TLS, is set up in the system and is outside this concern. Also in BTP/BAIP. (drafted with AI)

### UI & Frontend Bridge

- [SAP GUI screens and lists](https://onedevatlas.dev/capabilities/abap-classic-ui): Building screens, lists and interactive controls for the SAP GUI. Producing a web interface is UI written in ABAP; operating an existing screen programmatically is GUI automation. (drafted with AI)
- [UI written in ABAP](https://onedevatlas.dev/capabilities/abap-ui-from-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. (drafted with AI)

## BTP/BAIP

- [BTP/BAIP map](https://onedevatlas.dev/btp)
- Status: Early. The atlas already contains capabilities and artifacts but there is still a lot of the ecosystem to explore.
- [Reference architectures](https://onedevatlas.dev/btp/browse?show=readings&ctype=reference-architecture): 26 published designs behind this door, 8 with their parts read into the graph

### AI & Agents

- [Agent access to your systems](https://onedevatlas.dev/capabilities/agent-systems-access): Giving an AI agent access to the business data, configuration or operations of systems you run through an MCP server. Serving your application over MCP exposes your own service contract; system access reaches the systems behind it, and one implementation may do both. Development assistance belongs to agent access to your code. Also in ABAP, CAP, SAP Commerce, SAP SuccessFactors. (drafted with AI)
- [Agent workspaces](https://onedevatlas.dev/capabilities/agent-workspaces): Giving people a workspace to direct agents, retain the context of a task and interact with its results across connected applications. This is the user-facing experience around agents; building their logic belongs to Agent tooling, and controlling their calls belongs to Tool governance. (drafted with AI)
- [Content filtering](https://onedevatlas.dev/capabilities/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. Distinct from data masking, which hides values: a filter refuses content. Also in CAP. (drafted with AI)
- [Data masking](https://onedevatlas.dev/capabilities/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. Anonymisation, where the values are gone for good, and pseudonymisation, where they return, are the two forms; which fields count as sensitive is the application's question, not the module's. Also in CAP. (drafted with AI)
- [Document extraction](https://onedevatlas.dev/capabilities/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. The mirror image of document output, and a different problem from reading a service: the input is a file, the shape is unknown until something reads it, and the answer arrives with a confidence rather than a guarantee. Also in CAP, UI5. (drafted with AI)
- [Predictive models](https://onedevatlas.dev/capabilities/predictive-models): Training, deploying and calling a model that predicts a value from tabular business data: a classification, a regression, a forecast. Distinct from LLM integration, where a language model generates text, even where both run on the same service. (drafted with AI)
- [Prompt management](https://onedevatlas.dev/capabilities/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. What people conflate under it: the template filled at runtime, the registry it lives in, and the orchestration step that fills it. Also in CAP. (drafted with AI)

### Data & Persistence

- [Analytic modelling](https://onedevatlas.dev/capabilities/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. Distinct from analytical queries, which is a service answering the request a chart sends, and from loading a warehouse, which fills the tables underneath it. Also in ABAP. (drafted with AI)
- [Cataloguing and lineage](https://onedevatlas.dev/capabilities/data-cataloguing): 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. The question asked before modelling starts and again when somebody asks where a number came from. (drafted with AI)
- [Database administration](https://onedevatlas.dev/capabilities/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. Connecting an application to the database is database connectors, moving files in and out of tables is importing and exporting table data, and what the instance costs is consumption monitoring. (drafted with AI)
- [Graph, spatial and document data](https://onedevatlas.dev/capabilities/multi-model-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. Free-text search over entities is search; similarity over embeddings is retrieval-augmented generation. (drafted with AI)
- [Loading a warehouse](https://onedevatlas.dev/capabilities/warehouse-loading): 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. Distinct from replication, which is an application reading data that lives elsewhere as if it were local rather than a warehouse being filled. Also in ABAP. (drafted with AI)
- [Location services](https://onedevatlas.dev/capabilities/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. Storing geometries in the database and querying them there is graph, spatial and document data. Also in CAP. (drafted with AI)
- [Object storage](https://onedevatlas.dev/capabilities/object-storage): Storing application files as objects in a bucket or container backed by a cloud storage service. Connecting a file to a business record is the separate Attachments concern. (drafted with AI)

### Developer Experience

- [Architecture diagrams](https://onedevatlas.dev/capabilities/architecture-diagrams): Drawing the architecture and components of a solution so another person can understand their responsibilities and connections. Shared notation makes diagrams readable across teams. (drafted with AI)
- [CI/CD pipelines](https://onedevatlas.dev/capabilities/ci-cd): A pipeline that builds, tests and delivers an application each time its source repository changes, with a build log that shows which step failed. Deployment describes getting the build onto its target runtime. Also in CAP. (drafted with AI)
- [Low-code apps](https://onedevatlas.dev/capabilities/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. Starting a coded project from a template is generators, and building a native mobile client is mobile apps. (drafted with AI)

### Integration & Messaging

- [B2B message mapping](https://onedevatlas.dev/capabilities/b2b-message-mapping): Defining the structure of business messages exchanged between partners using different standards, and mapping one structure onto another. This includes interface specifications, schemas and transformations; executing them in middleware belongs to integration flows. (drafted with AI)
- [Integration flows](https://onedevatlas.dev/capabilities/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. Reaching a remote system from application code is destinations, and brokering events between systems is Event Mesh. (drafted with AI)
- [Integration scenario setup](https://onedevatlas.dev/capabilities/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. Integration flows move and transform the messages once the connection exists; this is the setup that runs before that. (drafted with AI)
- [Third-party connectors](https://onedevatlas.dev/capabilities/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. Pointing at an endpoint whose API you call yourself is destinations, and moving and mapping the messages is integration flows. (drafted with AI)
- [Trading partner agreements](https://onedevatlas.dev/capabilities/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. What a message looks like and how it maps is B2B message mapping, and executing the exchange is integration flows. (drafted with AI)

### Operations & Runtime

- [Account provisioning](https://onedevatlas.dev/capabilities/account-provisioning): Setting up cloud accounts, their organisational structure, resource entitlements, subscriptions and access assignments so the setup can be repeated from code. Deployment puts an application onto a runtime that this account structure makes available. (drafted with AI)
- [Application runtimes](https://onedevatlas.dev/capabilities/application-runtimes): The environments that execute application code and manage its processes, containers or managed language runtime. Getting a build onto one is deployment; serving a frontend’s built static files is app hosting. (drafted with AI)
- [Consumption monitoring](https://onedevatlas.dev/capabilities/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. Logging and telemetry watch what an application does; this watches what it costs. (drafted with AI)
- [Job scheduling](https://onedevatlas.dev/capabilities/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. Also in CAP, ABAP. (drafted with AI)
- [Operations automation](https://onedevatlas.dev/capabilities/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. Logging, telemetry and health checks observe; this acts on what they report. Running an application's own recurring work is job scheduling. (drafted with AI)
- [Platform migration](https://onedevatlas.dev/capabilities/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. Language-level compatibility is a separate concern from moving the platform around an application. Also in CAP. (drafted with AI)

### Process & Workflow

- [Process automation](https://onedevatlas.dev/capabilities/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. Starting a process from an application and reacting to it is workflow integration, and the screen a person approves a task on is task and approval UIs. (drafted with AI)
- [Responsibility assignment](https://onedevatlas.dev/capabilities/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. Running the process itself is process automation; the screen the responsible person acts on is task and approval UIs. (drafted with AI)

### Protocols & APIs

- [Health data interoperability](https://onedevatlas.dev/capabilities/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. (drafted with AI)

### Security & Compliance

- [Identity provisioning](https://onedevatlas.dev/capabilities/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. Authentication answers who is calling one request; provisioning decides whether the user exists in that system at all. (drafted with AI)
- [Malware scanning](https://onedevatlas.dev/capabilities/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. Also in CAP. (drafted with AI)
- [Secrets rotation](https://onedevatlas.dev/capabilities/secrets-rotation): Rotating credentials a running service depends on — service keys, destination credentials, API tokens — without downtime and without redeploying. Distinct from storing secrets, which the platform handles. Also in CAP. (drafted with AI)
- [Vulnerability scanning](https://onedevatlas.dev/capabilities/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. Checking a file somebody uploaded is malware scanning, and checking an application's own source for flaws is static analysis. Also in CAP, UI5. (drafted with AI)

### UI & Frontend Bridge

- [App hosting](https://onedevatlas.dev/capabilities/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. Also in UI5, CAP. (drafted with AI)
- [Launchpad and site content](https://onedevatlas.dev/capabilities/launchpad-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. Serving the application’s files is app hosting; extending the surrounding shell is launchpad plugins. Also in UI5. (drafted with AI)
- [Mobile apps](https://onedevatlas.dev/capabilities/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. Distinct from a web app opened in a phone's browser; operating a web app with a finger is touch operation. (drafted with AI)
- [Task and approval UIs](https://onedevatlas.dev/capabilities/task-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. Distinct from workflow integration, which is about driving the engine: this is the half a human touches, and its hard part is that it cannot run without the engine that normally feeds it. Also in UI5. (drafted with AI)

## SAP Digital Manufacturing

- [SAP Digital Manufacturing map](https://onedevatlas.dev/digital-manufacturing)
- Status: Early. The atlas already contains capabilities and artifacts but there is still a lot of the ecosystem to explore.

### UI & Frontend Bridge

- [POD plugins](https://onedevatlas.dev/capabilities/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. Distinct from launchpad plugins, which extend a launchpad's shell around many apps. (drafted with AI)

## Topics

- [Building onedevatlas](https://onedevatlas.dev/topics/building-onedevatlas): Building onedevatlas: the idea, the back-and-forth with AI, the wrong turns, and an orb who lost his permanent spot in the atlas. Edition 1, 2026-10-25. (drafted with AI)
- [The atlas is now in beta](https://onedevatlas.dev/topics/onedevatlas-is-open): onedevatlas is open for browsing. Find tools for SAP development, compare their documented capabilities, ask your AI assistant, and join a flight during TechEd week. Edition 1, 2026-10-26. (drafted with AI)

## Optional

- [@babel/plugin-transform-react-jsx](https://onedevatlas.dev/externals/babel-plugin-transform-react-jsx): outside the atlas — Babel's JSX transform. It compiles the JSX in a UI5 project's .tsx files into the _jsx and _jsxs calls that @ui5-community/jsx-runtime turns into UI5 control constructors, and is installed as an optional peer at version 7. (drafted with AI)
- [@langchain/mcp-adapters](https://onedevatlas.dev/externals/langchain-mcp-adapters): outside the atlas — LangChain's MCP integration for JavaScript, whose MultiServerMCPClient holds several MCP servers at once; for the things here it is how an agent in a CAP service gets its tools from deployed MCP servers instead of hand-written ones. (drafted with AI)
- [ABAP platform](https://onedevatlas.dev/externals/abap-platform): outside the atlas — SAP's application server and development platform for ABAP. For the things here it is the system a developer's editor or an agent's tool reaches over ADT, and a program calls over RFC; where it runs is the deployment's, as for SAP BW/4HANA. (drafted with AI)
- [Ajv](https://onedevatlas.dev/externals/ajv): outside the atlas — A JSON Schema validator for JavaScript. Where something here validates against JSON Schema rather than against the CDS model, Ajv is what compiles the schema and runs it. (drafted with AI)
- [Amazon Web Services](https://onedevatlas.dev/externals/aws): outside the atlas — Amazon's cloud platform, with accounts, regions, a command-line interface and CloudFormation templates that provision resources. For the things here it is the account an SAP tool is deployed into, next to the SAP systems it reads from. (drafted with AI)
- [Apache Kafka](https://onedevatlas.dev/externals/kafka): outside the atlas — A distributed event-streaming platform. For the things here it is the broker that carries messages between the parts of one application. (drafted with AI)
- [axios](https://onedevatlas.dev/externals/axios): outside the atlas — A promise-based HTTP client for the browser and Node.js, and the client a CAP module here hands an outbound request to once the destination has been resolved. (drafted with AI)
- [C3.js](https://onedevatlas.dev/externals/c3js): outside the atlas — A D3-based JavaScript charting library. For the things here it is the charting engine a UI5 control library wraps, so a chart is declared in an XML view instead of configured in JavaScript. (drafted with AI)
- [Claude API](https://onedevatlas.dev/externals/anthropic-claude-api): outside the atlas — Anthropic's hosted API for the Claude models, reached at https://api.anthropic.com/v1/messages with a key or through a destination. For the things here it is the model endpoint an ABAP system posts to, under the organisation's own agreement with Anthropic. (drafted with AI)
- [Cogniac EdgeFlow](https://onedevatlas.dev/externals/cogniac-edgeflow): outside the atlas — Cogniac's on-premise GPU appliance, running the company's inference engine at the edge on the same local network as the proxy that forwards camera frames to it, and producing the detections a POD plugin displays. (drafted with AI)
- [Databricks](https://onedevatlas.dev/externals/databricks): outside the atlas — A unified data and AI platform. sap-bdc-mcp-server creates the Delta shares it registers with SAP Business Data Cloud in a Databricks workspace. (drafted with AI)
- [Day.js](https://onedevatlas.dev/externals/dayjs): outside the atlas — A 2 kB JavaScript date library with the same API as Moment.js. For the things here it is what a UI5 control wraps so a view can parse, format and shift a date. (drafted with AI)
- [Deep Agents](https://onedevatlas.dev/externals/deepagents): outside the atlas — An agent harness published by LangChain as the npm package deepagents, with planning, filesystem and sub-agent tools included. For the things here, the harness whose filesystem backend protocol an implementation plugs into so the agent's files live in an SAP repository rather than on disk. (drafted with AI)
- [Docker](https://onedevatlas.dev/externals/docker): outside the atlas — A container engine that packages software with the tools it needs and runs it isolated from the host. Things here that ship as an image need it installed, so the reader installs the engine rather than each of the command line tools inside the container. (drafted with AI)
- [draw.io](https://onedevatlas.dev/externals/drawio): outside the atlas — A diagram editor, on the web and as a desktop app. The BTP diagram skills here write .drawio files, and a person opens and edits them in it. (drafted with AI)
- [DuckDB](https://onedevatlas.dev/externals/duckdb): outside the atlas — An in-process analytical SQL database. For the things here it is the engine an extension is loaded into, and where SAP data lands once it has been read: queried and joined there alongside files and other tables. (drafted with AI)
- [Eclipse IDE](https://onedevatlas.dev/externals/eclipse): outside the atlas — The Java-based IDE and plugin platform, downloaded as an archive per operating system and extended through p2 update sites. For the things here, the installation SAP's ABAP Development Tools and their companion plugins are added to. (drafted with AI)
- [EdgeFlow Proxy API](https://onedevatlas.dev/externals/cogniac-edgeflow-proxy): outside the atlas — A FastAPI service that runs on a Raspberry Pi with a libcamera-supported camera, captures frames and forwards them to a Cogniac EdgeFlow inference device, and exposes one HTTPS endpoint on the local network that a POD plugin in the browser calls. (drafted with AI)
- [FastEmbed](https://onedevatlas.dev/externals/fastembed): outside the atlas — A Python library for embedding generation, built on the ONNX Runtime rather than PyTorch and needing no GPU. For the things here it is what turns a chunk into a vector on the machine doing the work rather than through a hosted embedding service. (drafted with AI)
- [FFmpeg](https://onedevatlas.dev/externals/ffmpeg): outside the atlas — A command-line converter for audio and video. Where it is installed on the machine, web-abap2UI5's media pipeline uses it to write the .mp4 and .gif of a recorded app beside the .webm and .png it always produces. (drafted with AI)
- [GitHub](https://onedevatlas.dev/externals/github): outside the atlas — A hosted git service: repositories, pull requests with reviews, and branch rulesets that decide what may reach a branch. Things here that push objects out of an SAP system, or keep a review record outside it, call its API and open their pull requests on it. (drafted with AI)
- [GitHub Copilot](https://onedevatlas.dev/externals/github-copilot): outside the atlas — An AI coding assistant built into GitHub, with agents that can use external tools and MCP servers. (drafted with AI)
- [Google Gemini](https://onedevatlas.dev/externals/google-gemini): outside the atlas — Google's generative AI models, called over the Gemini API with a key Google bills to whoever holds it. For the things here it is the model a workspace sends its wording and naming proposals to once its own engine has read the code. (drafted with AI)
- [goose](https://onedevatlas.dev/externals/goose): outside the atlas — An extensible AI agent that runs tasks and connects to external tools, used as the local agent process behind a workspace. (drafted with AI)
- [Java Development Kit (JDK)](https://onedevatlas.dev/externals/jdk): outside the atlas — The Java runtime and tools a Java program is run with. For the things here, the full JDK an on-premises agent such as the Cloud Connector needs on its host. (drafted with AI)
- [jsDelivr](https://onedevatlas.dev/externals/jsdelivr): outside the atlas — A public content delivery network that serves files out of npm packages over the web. For the things here it is where a browser fetches the JavaScript library a control wraps, unless that library is vendored into the SAP system instead. (drafted with AI)
- [LangGraph](https://onedevatlas.dev/externals/langgraph): outside the atlas — An agent runtime that describes a loop as a graph of nodes and edges and carries the state between turns. For the things here it is the harness an agent's planning and tool calls run in, and the state that a CDS checkpointer persists. (drafted with AI)
- [Microsoft Excel](https://onedevatlas.dev/externals/microsoft-excel): outside the atlas — Microsoft's spreadsheet application, on Windows, the Mac and the web. For the things here it is the host of an Office add-in: it installs the add-in from a manifest, shows its page in a task pane and exposes the open workbook to that page through Office.js. (drafted with AI)
- [MongoDB](https://onedevatlas.dev/externals/mongodb): outside the atlas — A document database. Reached from CAP through an adapter over Mongoose rather than through the SQL database services. (drafted with AI)
- [NATS](https://onedevatlas.dev/externals/nats): outside the atlas — A messaging system. An option for teams that already run it and want events carried over it rather than over Event Mesh or Redis. (drafted with AI)
- [Node.js](https://onedevatlas.dev/externals/nodejs): outside the atlas — A cross-platform JavaScript runtime that servers, command line tools and scripts written in JavaScript are run with. For the things here, the prerequisite a repository names when its build is a set of npm scripts. (drafted with AI)
- [OpenRouter](https://onedevatlas.dev/externals/openrouter): outside the atlas — A service that provides access to AI models through one API endpoint, used by applications and agents for model requests. (drafted with AI)
- [OpenUI5 CDN](https://onedevatlas.dev/externals/openui5-cdn): outside the atlas — SAP's public delivery of OpenUI5 runtime releases, and where a browser tool here loads the UI5 it renders its canvas on when no local tree is configured. (drafted with AI)
- [Playwright](https://onedevatlas.dev/externals/playwright): outside the atlas — A library that drives Chromium, Firefox and WebKit from code, written for end-to-end browser testing. For the things here it is the browser a tool starts itself, to get through an SAP login or to load a page headless and photograph it. (drafted with AI)
- [PostgreSQL](https://onedevatlas.dev/externals/postgresql): outside the atlas — A relational database. For CAP it is the production database when the answer is not HANA, reached through an adapter that translates CDS queries into its SQL. (drafted with AI)
- [Postmark](https://onedevatlas.dev/externals/postmark): outside the atlas — A hosted transactional email provider, reached over an HTTP API with a server token. For the things here it is where an application hands over an approval-request email, and the sender keeps the retry rules because the API carries no idempotency key. (drafted with AI)
- [PyRFC](https://onedevatlas.dev/externals/pyrfc): outside the atlas — SAP's Python bindings over the SAP NetWeaver RFC SDK. For the things here it is what a Python program calls ABAP function modules through, and it carries the SDK's own prerequisite with it. (drafted with AI)
- [Qdrant](https://onedevatlas.dev/externals/qdrant): outside the atlas — A vector similarity search engine and vector database. For the things here it is where embedded chunks are stored and searched, running locally beside the process that wrote them or as a server of its own. (drafted with AI)
- [Redis](https://onedevatlas.dev/externals/redis): outside the atlas — An in-memory data store. For the things here it is the shared cache, the queue or the pub/sub channel that lets several application instances behave as one. (drafted with AI)
- [SAP BW/4HANA](https://onedevatlas.dev/externals/sap-bw4hana): outside the atlas — SAP's data warehouse product for on-premise and private-cloud landscapes, optimised for the HANA database and installed rather than subscribed — the 2023 release is current, with its own master and upgrade guides. Outside the atlas because there is no adoption decision to model: you have a BW system or you do not, and what is entered here is the tooling that reaches one. (drafted with AI)
- [SAP Cloud ALM](https://onedevatlas.dev/externals/sap-cloud-alm): outside the atlas — SAP's application lifecycle management product, run by SAP as a service: implementation projects with their tasks, requirements, features, documents and test management, and the operations side of a landscape. For the things here it is the system a server reads over the published Cloud ALM APIs, on behalf of an agent. (drafted with AI)
- [SAP Commerce Cloud](https://onedevatlas.dev/externals/sap-commerce-cloud): outside the atlas — SAP's commerce platform, once Hybris: a Java platform extended with extensions, ImpEx and its type system, run by SAP as SAP Commerce Cloud, with the composable storefront in front of it. The product behind the SAP Commerce door: what is entered there is the tooling that reaches into or builds on an instance, and the product itself is not an option. (drafted with AI)
- [SAP Companion](https://onedevatlas.dev/externals/sap-companion): outside the atlas — SAP Enable Now's web-based help system: a panel over the running application carrying help topics, guided tours, What's New and learning content. Its sap.dfa.help runtime is licensed and not published on the public UI5 CDN, so anything serving a Companion workarea is pointed at a copy the project supplies. (drafted with AI)
- [SAP Digital Manufacturing](https://onedevatlas.dev/externals/sap-digital-manufacturing): outside the atlas — SAP's manufacturing execution system for running production on the shop floor, run by SAP as software as a service. The product behind the SAP Digital Manufacturing door: what is entered there is what people build for it, such as plugins for its Production Operator Dashboard, and the product itself is not an option. (drafted with AI)
- [SAP ERP (ECC)](https://onedevatlas.dev/externals/sap-erp): outside the atlas — SAP's earlier ERP suite, ECC 6.0, run on-premise on the ABAP platform and succeeded by SAP S/4HANA. For the things here it is the system a tool reads from or writes to. (drafted with AI)
- [SAP Fiori launchpad](https://onedevatlas.dev/externals/sap-fiori-launchpad): outside the atlas — SAP's shell for SAP Fiori apps: it hosts them and gives them navigation, personalisation, embedded support and application configuration. For the things here it is the shell a KPI tile stands in, reading the number it shows from the system behind it. (drafted with AI)
- [SAP Focused Run](https://onedevatlas.dev/externals/sap-focused-run): outside the atlas — SAP's monitoring and operations product for large SAP landscapes, installed by a service provider or a customer rather than subscribed. For the things here it is the system a tool reads alerts and monitoring data from. (drafted with AI)
- [SAP LeanIX](https://onedevatlas.dev/externals/sap-leanix): outside the atlas — SAP's enterprise architecture management product, run by SAP as a service: the inventory of an organisation's applications, interfaces and technologies, and the fact sheets that describe them. For the things here it is the system a tool reads or updates over its APIs. (drafted with AI)
- [SAP NetWeaver RFC SDK](https://onedevatlas.dev/externals/sap-nw-rfc-sdk): outside the atlas — SAP's native library for calling ABAP functionality and for being called from ABAP. Downloaded from SAP under its own terms rather than from a package registry, so anything built on it carries that prerequisite per platform. (drafted with AI)
- [SAP Product Availability Matrix](https://onedevatlas.dev/externals/sap-product-availability-matrix): outside the atlas — SAP's list of its software releases on the SAP Support Portal, with release types, maintenance durations, planned availability, upgrade paths and supported platforms. For the things here it is the export a person downloads and converts themselves, the data they read. (drafted with AI)
- [SAP S/4HANA](https://onedevatlas.dev/externals/sap-s4hana): outside the atlas — SAP's ERP suite, run on-premise or as a private cloud edition, with its business data and processes reached over OData, RFC and the ABAP platform. For the things here it is the system a tool reads from or writes to. The public cloud edition is its own entry. (drafted with AI)
- [SAP S/4HANA Cloud Public Edition](https://onedevatlas.dev/externals/sap-s4hana-cloud-public-edition): outside the atlas — SAP's cloud ERP, run by SAP as software as a service. For the things here it is the business system a side-by-side application on BTP reads from and writes to over its published OData APIs. (drafted with AI)
- [SAP SuccessFactors](https://onedevatlas.dev/externals/sap-successfactors): outside the atlas — SAP's cloud HR suite, run by SAP as software as a service and reached from outside through its OData APIs. The product behind the SAP SuccessFactors door: what is entered there is the tooling that reaches into it, and the product itself is not an option. Its Extensibility service is a BTP service and sits on the BTP door, where SAP's catalogue lists it. (drafted with AI)
- [SQLite](https://onedevatlas.dev/externals/sqlite): outside the atlas — An embedded SQL database engine used as a selectable local cache store by CAP caching plugins. (drafted with AI)
- [Terraform](https://onedevatlas.dev/externals/terraform): outside the atlas — An infrastructure as code tool that defines cloud and on-premise resources in configuration files and creates or changes them through provider plugins. SAP publishes a plugin for BTP, so Terraform is the CLI a reader installs to run a BTP account's configuration. (drafted with AI)
- [ThingsBoard](https://onedevatlas.dev/externals/thingsboard): outside the atlas — An IoT platform for device connectivity, data collection and dashboards, installed on a single node from the compose file its own Docker guide publishes. For the things here it is the platform an edge stack runs and that SAP-side components are added around. (drafted with AI)
- [Tricentis Test Automation for SAP](https://onedevatlas.dev/externals/tricentis-test-automation-for-sap): outside the atlas — Tricentis' test automation product as SAP resells it: test case authoring for automated tests, test data services and support for the UIs and APIs of SAP products, entitled as a term licence to SAP customers under SAP Enterprise Support. For the things here it is the environment that imports and runs published test modules. (drafted with AI)
- [ui5.sap.com](https://onedevatlas.dev/externals/ui5-sap-com): outside the atlas — The host SAP serves the SAPUI5 SDK from, and where ui5-task-check-eocp retrieves the list of UI5 versions available to match a project's declared version against. (drafted with AI)
- [Vite](https://onedevatlas.dev/externals/vite): outside the atlas — A build tool and development server for web frontends. For the things here it is what bundles and serves a CAP project's frontend when a plugin brings the two under cds watch. (drafted with AI)
- [About](https://onedevatlas.dev/about): what the atlas is and how it is built
- [Protocols & APIs, across the doors](https://onedevatlas.dev/domains/protocols-and-apis): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/protocols-and-apis.json
- [Data & Persistence, across the doors](https://onedevatlas.dev/domains/data-and-persistence): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/data-and-persistence.json
- [Integration & Messaging, across the doors](https://onedevatlas.dev/domains/integration-and-messaging): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/integration-and-messaging.json
- [AI & Agents, across the doors](https://onedevatlas.dev/domains/ai-and-agents): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/ai-and-agents.json
- [Security & Compliance, across the doors](https://onedevatlas.dev/domains/security-and-compliance): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/security-and-compliance.json
- [Operations & Runtime, across the doors](https://onedevatlas.dev/domains/operations-and-runtime): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/operations-and-runtime.json
- [Developer Experience, across the doors](https://onedevatlas.dev/domains/developer-experience): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/developer-experience.json
- [UI & Frontend Bridge, across the doors](https://onedevatlas.dev/domains/ui-and-frontend-bridge): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/ui-and-frontend-bridge.json
- [Process & Workflow, across the doors](https://onedevatlas.dev/domains/process-and-workflow): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/process-and-workflow.json
- [Learning & Reference, across the doors](https://onedevatlas.dev/domains/learning-and-reference): the domain's capabilities with each door's own coverage, the designs that touch them and the content, as data at https://onedevatlas.dev/domains/learning-and-reference.json
- [Agents](https://onedevatlas.dev/agents): the MCP tools, the plugin and skill, and the static files, for connecting an agent
- [Neighbours](https://onedevatlas.dev/neighbours): the sources and lists the atlas credits
- [onedevatlas.json](https://onedevatlas.dev/manifest): the file a maintainer commits to state the facts about their own artifact; its schema at https://onedevatlas.dev/manifest/schema.json