70 docs tagged with "technical-knowledge"

A comprehensive A–Z reference of terms used in banking and payments. Essential reading for anyone joining the industry.

A bank is made up of many specialised teams. Understanding who does what helps you collaborate effectively, know who to escalate to, and understand where you.

These two messages form the **formal payment cancellation (recall) workflow**, allowing a payment to be recalled after it has been sent — even after settlement.

**Payment cards** (debit and credit) are one of the most widely used payment methods globally. They operate on **card schemes** — networks that define rules.

A conflict occurs when two branches have made **different changes to the same line(s)** of the same file, and Git cannot automatically determine which version.

A **consumer group** is a set of consumers that collectively consume a topic's partitions. Each partition is assigned to exactly one consumer within the group.

Consumer Lag measures how far behind a consumer group is from the latest messages in a topic. It is the most critical health metric for any Kafka-based application.

[Conventional Commits](https://www.conventionalcommits.org) is a lightweight convention for writing commit messages in a machine-readable, human-understandable.

The **Core Banking System (CBS)** is the central software platform that manages a bank's **primary banking operations** — account management, transaction.

Don't let your important business logic classes depend directly on concrete implementations (like a specific database driver, a specific email provider, etc.).

`git add` moves changes from your **working tree** into the **index** (also called the staging area). Think of the index as a draft of your next commit — you.

`git bisect` performs a **binary search through commit history** to efficiently find the exact commit that introduced a bug. Instead of checking commits one by.

A branch in Git is a **lightweight movable pointer** to a commit. Creating a branch costs nothing — it is just a 41-byte file containing a SHA. When you commit.

`git cherry-pick` copies one or more commits from anywhere in the repository and applies them to the current branch as new commits. The original commits remain.

`git commit` takes everything in the **index (staging area)** and creates a permanent, immutable snapshot in the repository. Each commit has:

Git configuration exists at three scopes, each overriding the one above it:

**The golden rule:** Prefer `git fetch` + manual inspect over `git pull` when you want to see what's changed before integrating. Use `git pull --rebase` for.

A **fixup** commit is a special type of squash commit that targets a specific earlier commit for amendment. When you run `git rebase --autosquash`, Git.

**Git Flow** is a branching model designed by Vincent Driessen for projects with scheduled, versioned releases. It defines a strict set of branch types and.

**Git hooks** are scripts that Git automatically executes before or after specific events (commit, push, merge, etc.). They live in `.git/hooks/` and can be.

**Git** is a distributed version control system (VCS) created by Linus Torvalds in 2005. Every developer has a full copy of the repository — including its.

`git log` shows the commit history of the current branch — or any branch, range, file, or author you specify.

`git merge` integrates the history of one branch into another. It finds the **common ancestor** of the two branches and combines their changes, creating a new.

`git push` uploads your local commits to a remote repository, making them available to other team members. It transfers only the objects (commits, trees.

`git rebase` moves or replays a sequence of commits onto a new base. It rewrites commit history by creating **new commits** with the same changes but different.

The **reflog** (reference log) is a local journal of every place `HEAD` and your branch pointers have pointed to, in chronological order. Every time you.

A **remote** is a named reference to another Git repository — typically hosted on GitHub, GitLab, Bitbucket, or an internal server. A remote stores a URL and a.

**Rule of thumb:** - Use `git reset` on **local, unpushed** changes - Use `git revert` on **pushed or shared** history

**Squashing** combines multiple commits into a single commit. This is used to clean up a messy feature branch before merging — turning a series of `wip`, `fix.

`git stash` temporarily shelves (stashes) your uncommitted changes — both staged and unstaged — so you can switch context without committing half-finished.

`git status` shows the state of your working tree and index relative to the current `HEAD` commit.

A **submodule** is a Git repository embedded inside another Git repository. The parent repository stores a reference to a specific commit of the submodule —.

A **tag** is an immutable pointer to a specific commit — unlike a branch, it never moves. Tags are used to mark release points (`v1.2.0`), milestones, or any.

`git worktree` lets you check out **multiple branches simultaneously**, each in its own directory, all sharing the same `.git` repository. No stashing, no.

Kafka uses a hash of the message key to determine partition assignment. Understanding this mechanism is essential for ordering guarantees, avoiding hot partitions, and designing correct partition keys.

Without idempotence, the standard retry flow can produce **duplicates**:

Interest and fees are the primary ways banks **generate revenue** from accounts and products. Understanding how they work is important for product.

Keep your interfaces **small and focused**. Don't create a "fat" interface that bundles unrelated methods together, forcing classes to implement things they.

**Q1: What are the three layers required for end-to-end exactly-once in Kafka?**

**Q1: Explain Kafka's architecture in 2 minutes.**

**Q1: Walk me through what happens when a producer calls `send()`.**

Welcome! This guide will walk you through the **SOLID principles** — five essential design principles that help you write Java code that is **clean, scalable.

**Q: Explain your current project flow from API request to database. What part of the systems do you own completely? What was the last production bug you fixed.

Producers ──► [ Broker Cluster ] ──► Consumers │ │ │ B1 B2 B3 │ ZooKeeper / KRaft

**Kafka Connect** is a framework for **reliably moving data between Kafka and external systems** (databases, file systems, cloud services) without writing.

A **consumer** reads messages from Kafka topics. Unlike traditional queues (push-based), Kafka consumers **pull** messages at their own pace. This gives.

Apache Kafka is a **distributed event streaming platform** designed for high-throughput, fault-tolerant, and scalable real-time data pipelines and streaming.

A **producer** is a client application that publishes (writes) messages to Kafka topics. It is responsible for:

A **topic** is a named, durable stream of messages in Kafka. Think of it as a logical category or feed where producers write and consumers read.

If class `B` extends class `A`, then anywhere you use `A`, you should be able to swap in `B` without anything breaking.

Kafka guarantees **total ordering within a partition**. Messages written to the same partition are always consumed in the exact order they were produced.

Consumer lag is the most important consumer metric:

Your class should be: - **Open for extension** → You can add new behavior - **Closed for modification** → You don't change existing, working code

`pacs.004` is the **interbank payment return message**. It is sent by the **Creditor Bank back to the Debtor Bank** when a previously received `pacs.008`.

**No — `pain.004` is not a defined ISO 20022 message.**

Payment reversals allow **the sending side** (debtor bank or originating customer) to request that a previously submitted payment be reversed — cancelling the.

A **partition** is an ordered, immutable sequence of records (a log) within a topic. Each partition lives on exactly one broker at a time (as leader) and.

If you're new to banking, the payment ecosystem can feel overwhelming. This page takes you from **zero to "I understand how a payment works"** using plain.

Kafka guarantees ordering within a partition, but single-threaded processing limits throughput. This guide covers four patterns for achieving high throughput while preserving per-key ordering.

The `acks` configuration controls **how many broker acknowledgements the producer requires before considering a send successful**. It directly trades off.

Idempotence protects against duplicates within a session, but it doesn't help when:

A pull request (PR) is a unit of communication as much as it is a unit of code change. A good PR:

The **replication factor** defines how many copies of each partition exist across the cluster.

Partitions are the unit of parallelism in Kafka. Scaling them is critical for throughput but can break ordering for keyed topics. This guide covers the mechanics, risks, and migration strategies.

**Schema Registry** is a centralized repository for managing and validating schemas for Kafka messages. It ensures that producers and consumers agree on the.

Every class should do **exactly one thing** and do it well. If a class is handling multiple unrelated responsibilities, then it has multiple reasons to change.

Congratulations! You've learned all 5 SOLID principles. Here's everything at a glance.

Testing in banking is **high-stakes** — a defect in a payment system can result in customer funds lost, duplicate payments, regulatory breaches, or system.

**Trunk-Based Development (TBD)** is a branching strategy where all developers integrate their changes into a single shared branch (`main` / `trunk`) multiple.

A comprehensive guide to bootstrap.yml in Spring Boot — covering the bootstrap context lifecycle, configuration server integration, spring.config.import evolution in Spring Boot 2.4+, and senior deep dives on pitfalls.