DEV Community: Khalil Habib Shariff

Rococo Supercharged Immutability, Time-Travel Debugging & Event-Driven Workflows

Khalil Habib Shariff — Tue, 18 Nov 2025 18:07:30 +0000

How Rococo Supercharged My Banking API: Immutability, Time-Travel Debugging & Event-Driven Workflows

When I started building a small banking API for learning purposes, I expected the hardest parts to be the API endpoints or the money transfer logic.

I was wrong.

The real challenge was data correctness over time.

If a customer deposits money, withdraws money, initiates a dispute, or reports that something went wrong earlier in the month, traditional CRUD becomes the enemy:

Updates erase history
Deletes destroy audit trails
Logs can’t rebuild financial state

In financial systems, data is not just data — it’s truth.

This is where Rococo, a Python versioning + event-sourcing framework, completely changed the game for me.

🧠 Why CRUD is a trap in banking

Imagine a basic workflow:


Start balance: $0
Deposit $100 → balance = $100
Withdraw $20 → balance = $80

In traditional systems, the balance column gets overwritten twice.

So when a customer asks:

“What was my balance before I withdrew $20 on January 12?”

You can’t answer — because the previous state is gone.

With Rococo, every state transition becomes a new immutable version, creating a perfect historical timeline instead of destructive updates.

🔥 Rococo’s magic: Immutable Version Models

Here’s what my Account model looks like with Rococo:

@dataclass
class Account(VersionedModel):
    def deposit(self, amount: float, actor_id: str) -> 'Account':
        return replace(
            self,
            balance=self.balance + amount,
            changed_by_id=actor_id,
            changed_on=datetime.utcnow(),
            previous_version=self.version,
            version=str(uuid.uuid4())
        )

Every deposit (or withdrawal) produces a brand-new version of the entity — nothing is overwritten.

This enables a superpower:

Time-travel debugging & dispute resolution

Calling:

GET /accounts/{account_id}/versions

returns the entire lifetime of an account:

Version	Balance	Actor	Timestamp
v1	$0	system	2024-01-01
v2	$100	user-123	2024-01-02
v3	$80	user-123	2024-01-03

Now when a user claims:

“My balance is wrong”

I don’t guess.
I show the exact historical truth.

🔒 Built-in audit trail — without writing custom audit code

Rococo automatically records:

previous version
new version
who made the change
when it happened

Here’s the kind of audit schema it creates:

id | entity_id | version | previous_version | balance | currency |
created_by_id | created_on | active

I didn’t write any audit logic at all — Rococo handled everything.

⚡ Event-driven architecture with zero friction

The next killer feature: auto-publishing events when an entity changes.

self.repo = BaseRepository(
    adapter=self.adapter,
    model=Account,
    message_adapter=self.message_adapter,
    queue_name="account_events"
)

Now every account update generates a message on the event bus (RabbitMQ, SQS, etc.)

This allowed my system to:

trigger fraud detection workflows
sync account balances to analytics
push updates to the frontend in real-time
track money movement in parallel systems without polling

Event-driven UX with almost no extra code.

🧩 System Architecture of the Project

FastAPI  ⟶  Service Layer  ⟶  Rococo Repository  ⟶ PostgreSQL
                                             ⟶ Audit Table
                                             ⟶ Event Bus

Frontend stack: Vue 3
Backend stack: FastAPI + Rococo
Database: PostgreSQL

🔗 GitHub Repository: https://github.com/Khaleelhabeeb/banking_ledger
🔗 Live Demo: https://bankingledger.vercel.app

🏁 Final Thoughts

Rococo didn’t just make my banking API work —
it made it correct, traceable, and auditable.

Without extra effort, I gained:

Zero-loss history of data
Permanent audit trail
Time-travel debugging
Event sourcing with minimal complexity

If you’re working in a domain where truth and history matter more than speed, Rococo deserves a spot in your toolbox.

💬 Want to chat?

I’m actively experimenting with Rococo and plan to build more adapters (DynamoDB next 👀).

If you’re working with Rococo, event-driven architectures, or just enjoy these concepts — I’d love to connect.

Thanks for reading! 🙌

Understanding python Decorators

Khalil Habib Shariff — Mon, 04 Mar 2024 19:43:51 +0000

Understand Python Decorators: A Twist on Functions

Have you ever encountered the @ symbol used with functions in Python and wondered what it meant? That's the magic of decorators, a unique concept that adds functionality to existing functions without altering their original code.

So, what are decorators?

Imagine wrapping a present. The present itself (the function) remains unchanged, but the wrapping (the decorator) adds something extra – maybe a bow or a ribbon. Similarly, a decorator "wraps" a function, adding new features or modifying its behavior.
Let's see an example:

import time

def timer(func):
    #Decorator that logs the execution time of a function.

    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.2f} seconds to execute.")
        return result

    return wrapper

@timer
def my_function(a, b):
    #This function does some calculations.
    return a * b + 5

result = my_function(3, 4)
print(result) # Output: my_function took 0.00 seconds to execute.

Here, the timer decorator is a function that takes another function (func) as its argument. It then defines an inner function (wrapper) that executes the original function (func) and logs its execution time. Finally, the decorator returns the wrapper function, which replaces the original one.

Benefits of using decorators:
Code Reusability: You can create reusable decorators for common tasks like logging, authentication, or caching, avoiding repetitive code.

Maintainability: Code becomes cleaner and easier to understand by separating concerns (core functionality and additional features).

Flexibility: You can easily add or remove functionalities using decorators without modifying the original function code.

Decorators are versatile and can be used for various purposes:
Such AS:
-Logging, Authentication, Caching, Validation

Remember, decorators add a unique twist to functions in Python, making them a powerful tool for writing clean, maintainable, and feature-rich code. So, embrace the fun and start decorating your functions today.

Building A Simple API For Your ML Model With FastAPI

Khalil Habib Shariff — Sat, 23 Dec 2023 12:17:07 +0000

Machine learning models are powerful tools, but their impact is often confined to notebooks and research environments. To realize their full potential, we need to integrate them into real-world applications. FastAPI offers a streamlined and efficient way to create APIs that bridge this gap, making your models accessible to diverse use cases.
In this post, I will guide you through the process of building a simple API for a plant disease classification model using FastAPI.

KEY STEPS

Install FastAPI and Dependencies:

pip install fastapi uvicorn[standard] tensorflow numpy pillow

2.Create Your FastAPI App:

from fastapi import FastAPI, File, UploadFile, BackgroundTasks
# ... other imports

app = FastAPI()

3.Load Your Trained Model:

model = keras.models.load_model('./models/model.weights.best.hdf5')

4.Define Prediction Function:

async def predict_leaf_class(image: UploadFile):
    # ... image preprocessing and prediction logic
    return predicted_class

5.Create API Endpoint:

@app.post("/predict")
async def predict_leaf_disease(image: UploadFile = File(...)):
    predicted_class = await predict_leaf_class(image)
    return JSONResponse(content={"predicted_class": predicted_class})

6.Enable CORS (Optional):

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Adjust for production
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

7.Run The API

uvicorn main:app --reload

You can find the complete code in this repo [https://github.com/Khaleelhabeeb/Fastapi-ML-Model-API]

Conclusion
FastAPI simplifies the process of creating robust and scalable APIs for machine learning models. By following these steps, you can effectively share your models with other applications and users, enabling a wider range of practical applications.
visit [https://github.com/Khaleelhabeeb/Fastapi-ML-Model-API]

What's New In Flask 3.0

Khalil Habib Shariff — Mon, 30 Oct 2023 19:18:43 +0000

Flask 3.0: Now with more features and customization!

Flask is a popular Python web framework that is known for its simplicity and flexibility. Flask 3.0 is a major release that includes a number of new features and improvements.

Here is a summary of the most important new features in Flask 3.0:

New customization points for many previously global behaviors. This makes it easier to tailor Flask to your specific needs. For example, you can now customize the way that Flask handles errors, redirects, and JSON serialization.
Added the View.init_every_request class attribute. If a view subclass sets this to False, the view will not create a new instance on every request. This can be useful for performance-critical views. -** Teardown functions are always run at the end of the request, even if the context is preserved**. They are also run after the preserved context is popped. This ensures that cleanup code is always executed, even if an exception is raised.
The CLI does not pass script_info to app factory functions. This avoids a potential conflict between the script_info and the URL_PREFIX configuration option.
config.from_json is replaced by config.from_file(name, load=json.load). The new API is more flexible and allows you to use other JSON libraries besides the standard library's json module.
json functions no longer take an encoding parameter. JSON encoding is now handled internally by Flask, so you no longer need to specify the encoding explicitly.
safe_join is removed. Use werkzeug.utils.safe_join instead. This ensures that the safe_join function is always available, even if you are not using Flask's default dependency injection container.
total_seconds is removed. Use timedelta.total_seconds instead. This change reflects the fact that timedelta is the preferred way to represent time intervals in Python.
The same blueprint cannot be registered with the same name. Use name= when registering to specify a unique name. This prevents conflicts between blueprints with the same name.

In addition to these new features, Flask 3.0 also includes a number of bug fixes and performance improvements.

Here are some examples of how to use the new features in Flask 3.0:

Customizing global behaviors
To customize a global behavior, you can now use the app.customizer dictionary. This dictionary maps behavior names to functions that can be used to customize the behavior.

For example, to customize the way that Flask handles errors, you could use the following code:

from flask import Flask, render_template

app = Flask(__name__)

app.customizer["errorhandler"][404] = lambda e: render_template("404.html")

if __name__ == "__main__":
    app.run(debug=True)

This code tells Flask to use the 404.html template to render a 404 error page.

To use the View.init_every_request class attribute, you can simply set it to False in your view subclass. For example:

from flask import Flask, render_template

app = Flask(__name__)

class MyView(flask.View):
    init_every_request = False

    def dispatch_request(self):
        return render_template("my_view.html")

app.add_url_rule("/my_view", view_func=MyView.as_view("my_view"))

if __name__ == "__main__":
    app.run(debug=True)

This code tells Flask to only create a new instance of the MyView class on the first request. On subsequent requests, Flask will reuse the existing instance.

Overall, Flask 3.0 is a significant release with a number of new features and improvements. If you are using Flask, I encourage you to upgrade to version 3.0 as soon as possible.

How To Connect Flask App To Any Database

Khalil Habib Shariff — Mon, 23 Oct 2023 20:53:15 +0000

Connecting Flask to MySQL, PostgreSQL, MongoDB, and Firebase

Flask is a lightweight and flexible web framework for Python. It is a popular choice for developing web applications of all sizes.

Flask does not come with a built-in database abstraction layer (DAL). This means that developers need to choose and install a third-party DAL such as SQLAlchemy or Peewee.

Here are some tips on how to connect Flask to MySQL, PostgreSQL, MongoDB, and Firebase:

Connecting Flask to MySQL

To connect Flask to MySQL, you will need to install the MySQLdb library. Once you have installed MySQLdb, you can import it into your Flask application and create a connection to the MySQL database.

Here is an example of how to connect Flask to MySQL:

pip install Flask-MySQLdb
pip install PyMySQL

from flask import Flask
import MySQLdb

app = Flask(__name__)

# Create a connection to the MySQL database
db = MySQLdb.connect(
    host='localhost',
    user='root',
    password='password',
    database='my_database',
)

# Create a cursor object
cursor = db.cursor()

# Execute a SQL query
cursor.execute('SELECT * FROM users')

# Get the results of the query
results = cursor.fetchall()

# Close the cursor and the connection
cursor.close()
db.close()

if __name__ == '__main__':
    app.run(debug=True)

Connecting Flask to PostgreSQL

To connect Flask to PostgreSQL, you will need to install the psycopg2 library. Once you have installed psycopg2, you can import it into your Flask application and create a connection to the PostgreSQL database.

Here is an example of how to connect Flask to PostgreSQL:

from flask import Flask
import psycopg2

app = Flask(__name__)

# Create a connection to the PostgreSQL database
conn = psycopg2.connect(
    host='localhost',
    user='postgres',
    password='password',
    database='my_database',
)

# Create a cursor object
cursor = conn.cursor()

# Execute a SQL query
cursor.execute('SELECT * FROM users')

# Get the results of the query
results = cursor.fetchall()

# Close the cursor and the connection
cursor.close()
conn.close()

if __name__ == '__main__':
    app.run(debug=True)

Connecting Flask to MongoDB

To connect Flask to MongoDB, you will need to install the pymongo library. Once you have installed pymongo, you can import it into your Flask application and create a connection to the MongoDB database.

Here is an example of how to connect Flask to MongoDB:

from flask import Flask
import pymongo

app = Flask(__name__)

# Create a connection to the MongoDB database
client = pymongo.MongoClient('localhost', 27017)
db = client['my_database']

# Get the users collection
users_collection = db['users']

# Find all users
users = users_collection.find()

# Close the connection
client.close()

if __name__ == '__main__':
    app.run(debug=True)

Connecting Flask to Firebase

To connect Flask to Firebase, you will need to install the Pyrebase library. Once you have installed Pyrebase, you can import it into your Flask application and initialize the Firebase Realtime Database.

Here is an example of how to connect Flask to Firebase:

from flask import Flask
import pyrebase

app = Flask(__name__)

# Initialize the Firebase Realtime Database
config = {
    'apiKey': 'YOUR_API_KEY',
    'authDomain': 'YOUR_AUTH_DOMAIN',
    'databaseURL': 'YOUR_DATABASE_URL',
    'projectId': 'YOUR_PROJECT_ID',
    'storageBucket': 'YOUR_STORAGE_BUCKET',
    'messagingSenderId': 'YOUR_MESSAGING_SENDER_ID'
}

firebase = pyrebase.initialize_app(config)

# Get the users reference
users_ref = firebase.database().reference('users')

# Get all users
users = users_ref.get()

if __name__ == '__main__':
    app.run(debug=True)

These are just a few examples of how to connect Flask to MySQL, PostgreSQL, MongoDB, and Firebase. There are many other ways to do this, and the best approach for you will depend on your specific needs.

A Beginner's Guide To Creating a Simple RESTful API with Python Flask

Khalil Habib Shariff — Fri, 28 Jul 2023 13:56:14 +0000

Step 1: Setup
First, make sure you have Python installed on your system. You can download Python from the official website:(https://www.python.org/downloads/)

Next, install Flask using pip, the Python package manager. Open a terminal or command prompt and run the following command:

pip install Flask

Step 2: Create the Flask App
Create a new Python file (e.g., app.py) and import the necessary modules:

from flask import Flask, jsonify, request

Next, initialize the Flask app:

app = Flask(__name__)

Step 3: Define Routes and Endpoints
In Flask, you define routes using the @app.route decorator. Each route corresponds to a specific URL, and each URL will be associated with a function that handles the request and returns the response.

Let's create a simple API with two endpoints: one to get a list of items and another to get details of a specific item.

# Sample data - you can replace this with your own data or use a database
items = [
    {"id": 1, "name": "Item 1"},
    {"id": 2, "name": "Item 2"},
    {"id": 3, "name": "Item 3"}
]

# Endpoint to get all items
@app.route('/api/items', methods=['GET'])
def get_items():
    return jsonify(items)

# Endpoint to get details of a specific item
@app.route('/api/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    item = next((item for item in items if item['id'] == item_id), None)
    if item:
        return jsonify(item)
    return jsonify({"message": "Item not found"}), 404

Step 4: Run the Flask App
At the end of your app.py file, add the following lines to run the app:

if __name__ == '__main__':
    app.run(debug=True)

Step 5: Test the API
Save the file and run it using the following command in the terminal:

python app.py

Your Flask app should now be running locally at http://127.0.0.1:5000/.

To test the API, you can use tools like curl, Postman, or simply use your web browser.

To get all items, open your web browser and go to http://127.0.0.1:5000/api/items.
To get details of a specific item (e.g., item with ID 2), go to http://127.0.0.1:5000/api/items/2.
Congratulations! You have just created a simple RESTful API with Python and Flask. From here, you can continue exploring more advanced features of Flask, like handling POST, PUT, and DELETE requests, using a database, authentication, etc. Happy coding!.

Building a Simple API with Node.js and Express

Khalil Habib Shariff — Sat, 29 Apr 2023 14:00:33 +0000

1.Setting Up the Project:
To get started, create a new directory for your project and navigate into it using the terminal. Then, initialize a new Node.js project by running the following command:

npm init -y

This will create a package.json file in your project directory, which is used to manage your project's dependencies and scripts.

Next, install the express package by running the following command:

npm install express

This will install express and its dependencies in your project.

2.Creating a Simple Server:
Create a new file called server.js in your project directory, and add the following code:

const express = require('express');
const app = express();

app.listen(3000, () => {
  console.log('Server is listening on port 3000');
});

This code imports the express package and creates a new instance of the express application. We then call the app.listen() method to start the server and listen for incoming requests on port 3000.

3.Creating Routes:
To create a route, we need to define an HTTP method and a URL path, and associate it with a callback function that will handle the request. In express, we can use the app.get(), app.post(), app.put(), and app.delete() methods to define routes for different HTTP methods.
For example, let's create a route that responds to GET requests to the root URL ('/'):

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

This code defines a route for GET requests to the root URL ('/'), and sends a response with the text 'Hello, world!'.

4.Parsing Request Bodies:
To parse request bodies, we can use the body-parser package. First, install the package by running the following command:

npm install body-parser

Then, import it in your server.js file and use it as middleware:

const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

This code tells express to use the body-parser middleware to parse request bodies encoded in URL-encoded form or JSON format.

5.Creating Routes that Handle Data:
Let's create another route that responds to POST requests to the /items URL, and expects a JSON-encoded request body with an id and a name property. We'll store the items in an array for now:

let items = [];

app.post('/items', (req, res) => {
  const { id, name } = req.body;
  items.push({ id, name });
  res.status(201).json({ message: 'Item created', item: { id, name } });
});

This code defines a route for POST requests to the /items URL, and uses destructuring to extract the id and name properties from the request body. We then push the new item to the items array and send a response with a JSON-encoded message and the new item.

6.Testing the API:
To test your API, start the server by running the following command in your project directory:

node server.js

Then, use a tool like curl or Postman to send requests to your API and verify that it works as expected.

Congratulations, you've created a simple API with Node.js! Of course, this is just the beginning - there's a lot more to learn about Node.

A Beginner's Guide to Creating a RESTful API with Node.js

Khalil Habib Shariff — Sun, 26 Mar 2023 00:22:33 +0000

Creating a simple API using Node.js is a common use case for the platform, and there are several libraries and frameworks available to make the process easier. Here's a brief overview of how to create a simple API using Node.js.

1.Choose a framework: There are several popular Node.js frameworks for building APIs, such as Express, Hapi, and Koa. For this example, we'll use Express.

2.Install dependencies: Once you've chosen a framework, you'll need to install the necessary dependencies. For Express, you'll need to install the express and body-parser packages. You can do this using the npm package manager:

npm install express body-parser

Create a basic server: Create a new file called server.js, and add the following code:

const express = require('express');
const bodyParser = require('body-parser');

const app = express();

app.use(bodyParser.json());

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

const port = process.env.PORT || 3000;

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

This creates a basic Express server that listens for HTTP requests on port 3000 (or the value of the PORT environment variable, if set). When a GET request is made to the root URL ('/'), the server responds with the string 'Hello, world!'.

4.Add API routes: To create an API, you'll need to define routes that handle different HTTP methods (such as GET, POST, PUT, and DELETE) and perform actions based on the request parameters. For example, to create a route that returns a list of items, you could add the following code:

const items = ['apple', 'banana', 'orange'];

app.get('/items', (req, res) => {
  res.json(items);
});

This defines a new route that listens for GET requests to the '/items' URL. When a request is received, the server responds with a JSON array containing the items array defined earlier.

5.Test the API: You can test the API using a tool like Postman or cURL. For example, to test the '/items' route, you can send a GET request to http://localhost:3000/items. The server should respond with a JSON array containing the items.