DEV Community: Bipin Radhakrishnan

Why I Built CapLog: A Local-First Desktop App for Journaling and Tasks

Bipin Radhakrishnan — Wed, 15 Jul 2026 03:52:57 +0000

Two months ago my desk had a stack of sticky notes on the monitor, a handwritten journal I kept forgetting to open, a OneNote tab for quick notes, and — if I'm honest — usually three or four Notepad windows open with things I didn't want to lose. None of it talked to each other. A task I jotted on a sticky note had no connection to the journal entry about the day I wrote it in. Finding anything meant digging through four different places and hoping I remembered which one.

I wanted one app that could handle two things I kept doing separately: journaling my day and tracking my tasks. So I built CapLog, a local-first desktop app where the log, the todos, and the history all live together in a single SQLite database.

The problem: a desk full of sticky notes and a dozen open Notepad windows

Most productivity tools make you pick a lane. Journaling apps are built for writing and treat tasks as an afterthought. Todo apps are built for tasks and don't want your rambling notes about how the day actually went. Cloud tools solve neither problem — they just add a login screen and a sync spinner to the same fragmented setup.

None of my existing tools were bad on their own. OneNote is fine for what it does. A paper journal is fine too. The problem was running all of them at once for one continuous stream of "what happened today and what do I still need to do." I wanted:

a place to write a quick note about my day,
a way to turn that note into something I could look back on,
a place to capture tasks as I thought of them, without opening a second app,
and a history I could actually search instead of flipping through notebook pages.

That's the gap CapLog fills. It isn't trying to replace every note app or task manager on the market. It's trying to be the one app I keep open while I work.

Why local, why desktop

I wanted CapLog to be local and secure, and those two things turned out to be the same decision. Local meant the data stays on my machine — no server holding my daily logs, no account to lose access to, no sync conflicts to resolve at 11 PM. Desktop meant no browser tab competing for my attention and no "sign in to continue" between me and a quick note.

Once I committed to desktop and local, the rest of the product got simpler to reason about. SQLite became the single source of truth. Export became "write a file to disk," not "call an API." And AI — which I wanted for formatting, not as a requirement — became something the app could do without. If AI is off or the request fails, CapLog just saves your raw text as a Markdown bullet. The app doesn't stop working because a network call didn't.

Security here isn't a checklist item, it's a side effect of the architecture: there's no application server in the middle, no custom backend API to secure, and no routine transmission of your logs anywhere. Data leaves the machine only when you explicitly turn on AI formatting or export a file.

What CapLog actually does

CapLog is deliberately small. You type into one input, and the app turns that into either a Markdown journal entry or a task, depending on what you type:

Plain text becomes a log entry.
/todo creates a task.
/important marks a high-priority task.
/done completes an existing task.

If an AI provider is configured, it cleans up and formats the entry the moment you submit it. If it isn't, your text is saved exactly as you typed it, wrapped in a Markdown bullet. Either way, it lands in the same place: one local SQLite database, one feed, one history.

That's the entire interaction model. No folders to organize, no tags to maintain, no settings to tune before you can start using it.

How it's built: no backend, anywhere

CapLog is a Tauri v2 desktop app: a React and TypeScript frontend running in a native webview, with SQLite accessed directly through tauri-plugin-sql. The Rust side exists to host the window and wire up plugins — its invoke_handler is empty. There's no custom backend, and that includes the AI calls: when a provider is configured, the renderer talks straight to api.anthropic.com or an OpenAI-compatible endpoint over fetch(), using an API key stored in the local SQLite settings table.

The codebase follows a strict, one-directional layering: components handle UI, hooks connect the UI to data through TanStack Query, repository modules hold the SQL and return typed domain objects, and db.ts is the thin wrapper over SQLite. Only repos are allowed to touch db.ts — components never call the database directly. That rule keeps the UI from knowing anything about SQL, and it means the storage layer is isolated enough that it could be swapped out later without touching the rest of the app.

Data flow is just as plain. You type into the chat-style input, CapLog figures out whether it's a log entry or a slash command, formats it if AI is on, writes it, and TanStack Query invalidates the affected caches so the feed refreshes. Fewer moving parts between typing and saved data means fewer things that can break.

Content is stored as Markdown, not HTML, which keeps export simple and the renderer safe — CapLog uses a Markdown renderer with raw HTML disabled rather than trusting arbitrary HTML from the app's own history or a model's response.

Archive search follows the same layering, and it's intentionally simple. archiveRepo.searchDates(year, q) runs one SQL query — SELECT DISTINCT date FROM log_entries WHERE date LIKE '{year}-%' AND formatted_text LIKE '%{q}%' — scoped to the selected year, matching against the formatted (AI-cleaned) Markdown text. useArchiveSearch wraps that in a TanStack Query hook keyed on ['archive', 'search', year, q], only firing once you've typed something. The archive modal takes the resulting dates and highlights them on the year calendar; click one and it opens that day's log.

It's a substring match, not full-text or fuzzy search — no ranking, no tokenization, and it only searches log entries, not todos. Switching years re-runs the query. That's a deliberate tradeoff: it's fast, it's easy to reason about, and it covers the actual use case of "I remember roughly what I wrote, help me find the day." A smarter search engine is on the list of things that could get built later, but it hasn't earned its complexity yet.

Two months in

I've been using CapLog daily for two months now, and the sticky notes are gone. So is the handwritten journal, the OneNote tab, and the pile of open Notepad windows. Everything that used to live scattered across four places now lives in one feed I actually look back on, because looking back doesn't mean digging through a notebook or hunting for the right Notepad window.

The foundation is there: local storage, structured logs, task tracking, history and archive views, optional AI formatting, and export to a plain Markdown file. What's left is polish, not new scope — small improvements that make the daily habit smoother, not new features that make the app bigger.

Try it, or steal the idea

CapLog is open source: github.com/rbipin/caplog. If you're juggling the same scattered setup — a notes app here, a todo app there, a journal you keep meaning to open — clone it and see if one input box is enough for you too. And if it isn't quite right for how you work, the architecture is small enough to fork and bend into your own shape: layered frontend, local SQLite, no backend to fight with.

Alternate ways to intercept and manipulate Response in Asp.Net Core- Part 3

Bipin Radhakrishnan — Sun, 07 Jun 2020 14:59:53 +0000

The Problem

I have a web API with two endpoints, the endpoints serve mapped data in XML format for two different vendors. The result of both the endpoints is the same object but there are some differences like namespaces. The problem is how to return the same object with only namespaces serialized differently? I didn't want to go with the obvious solution of serializing the object with the different namespaces and returning them.

Solution 3

This approach is a mix of solution 1 and Solution 2.

Create Action Filters for the two endpoints, also created two output formatters like in solution 1 for both the endpoints. In the action filter, get the result object and add the output formatters to the formatters of the result.

Pros and Cons of the solution

Pros

The MVC pipeline remains unaltered, unlike Solution 1.
Because there is a separate action filter, there is a clear separation of concerns. Code is well separated, i.e business logic is taken care of by the API, and formatting the output is achieved by the formatters.
We are not writing into the response body here like solution 2, so the middleware in the pipeline will not be affected in case any middleware alters the response.

Cons

I haven't found any yet. Let me know in case any finds any.

Implementation

Step 1

I created two Action Filters one for the Washington weather station endpoint and Quebec endpoint.

The snippet of the new Action Filter

public class QubecCanadaOuputFilterAttribute : ActionFilterAttribute
    {
        public override async void OnResultExecuting(ResultExecutingContext context)
        {
            var response = context.HttpContext.Response;
            if (response.StatusCode != 200)
            {
                base.OnResultExecuting(context);
            }
            var result = context.Result as ObjectResult;
            result.Formatters.Add(new QuebecCanadaOutputFormatter());

            base.OnResultExecuting(context);
        }
    }

Step 2

Next created two output formatters for the endpoints, one for Washington and other for Quebec Canada endpoint

The snippet of one of the output formatters

 public class QuebecCanadaOutputFormatter : XmlSerializerOutputFormatter
    {
        public QuebecCanadaOutputFormatter()
        {

        }
        public QuebecCanadaOutputFormatter(XmlWriterSettings xmlWriterSettings) : base(xmlWriterSettings)
        {

        }
        protected override void Serialize(XmlSerializer xmlSerializer, XmlWriter xmlWriter, object value)
        {
            var namespaces = new XmlSerializerNamespaces();
            namespaces.Add("WS", "http://www.qubeccanadaweatherstation.com/xml/namespaces/type");
            namespaces.Add("Metric", "http://www.qubeccanadaweatherstation.com/xml/namespaces/siunit/temperature");
            xmlSerializer.Serialize(xmlWriter, value, namespaces);
        }
    }

I created a middleware called SimpleMiddleware in the solution. The middleware simply sets the response status to 200.

Output

Endpoint 1: Washington Weather Staion

<WeatherForecast xmlns:WS="http://www.wausweatherStation.com/xml/namespaces/type" xmlns:Metric="http://www.wausweatherstation.com/xml/namespaces/siunit/temperature">
<Date>2020-06-02T13:50:52.5094204-04:00</Date>
<Temperature>
<Celsius>8</Celsius>
<Farenheit>46</Farenheit>
</Temperature>
<Summary>Mild</Summary>
</WeatherForecast>

Endpoint 2: Quebec Canada

<WeatherForecast xmlns:WS="http://www.qubeccanadaweatherstation.com/xml/namespaces/type" xmlns:Metric="http://www.qubeccanadaweatherstation.com/xml/namespaces/siunit/temperature">
<Date>2020-06-02T13:56:09.5506734-04:00</Date>
<Temperature>
<Celsius>34</Celsius>
<Farenheit>93</Farenheit>
</Temperature>
<Summary>Cool</Summary>
</WeatherForecast>

Code

The sample code for solution 3 is here

or https://github.com/BipinBlog/asp.net_response_manipulation

Solution : OutputFormatters_in_result.sln

Alternate ways to intercept and manipulate response in Asp.Net core - Part 2

Bipin Radhakrishnan — Sun, 07 Jun 2020 14:36:01 +0000

The Problem:

I have a web API with two endpoints, the endpoints serve data in XML format for two different vendors. The result of both the endpoints is the same object but there are some differences like namespaces. The problem is how to return the same object with only namespaces serialized differently? I didn't want to go with the obvious solution of serializing the object with the different namespaces and returning them.

Solution 1

Solution 2

Create Action Filters for the endpoints and manually serialize the output in the OnResultExecuting() method and write the serialized output to the response body.

Pros and Cons of the solution

Pros

The MVC pipeline remains unaltered, unlike Solution 1.
Because there is a separate action filter, there is a clear separation of concerns. Code is well separated, i.e business logic is taken care of by the API, and formatting the output is achieved by the formatters.

Cons

Since we start writing the response body, further manipulation of response is not possible. This is demonstrated in the mode using a middleware.  ### Implementation

Step 1:

I created two action filters one for the Washington weather station endpoint and Quebec endpoint.

Then I created a custom XML serializer to serialize the object into XML.

Step 2

Use the XML serializers in the corresponding action filters and serialize the object, here is a snippet from Washington action filter

// Action Filter
public class WashingtonOuputFilterAttribute : ActionFilterAttribute
    {
        public override async void OnResultExecuting(ResultExecutingContext context)
        {
            var response = context.HttpContext.Response;
            if (response.StatusCode != 200)
            {
               base.OnResultExecuting(context);
            }
            var result = context.Result as ObjectResult;
            var serializedResult = WashingtonOutputSerializer.Instance.Serialize(result.Value);
            var resultBytes = Encoding.UTF8.GetBytes(serializedResult);
            response.Headers.Add("Content-Type","application/xml");
            await response.Body.WriteAsync(resultBytes, 0, resultBytes.Length);
            base.OnResultExecuting(context);
        }
    }

Here is the code of lazy-loaded singleton Washington XML Serializer

//Washington XML Serializer
 public class WashingtonOutputSerializer
    {
        public static readonly Lazy<WashingtonOutputSerializer> lazyWashingtonSerializer =
            new Lazy<WashingtonOutputSerializer>(() => new WashingtonOutputSerializer());
        public static WashingtonOutputSerializer Instance
        {
            get { return lazyWashingtonSerializer.Value; }
        }
        private WashingtonOutputSerializer() { }
        public string Serialize(object outputObject)
        {
            var namespaces = new XmlSerializerNamespaces();
            namespaces.Add("WS", "http://www.wausweatherStation.com/xml/namespaces/type");
            namespaces.Add("Metric", "http://www.wausweatherstation.com/xml/namespaces/siunit/temperature");
            return XMLSerializer.Instance.Serialize(outputObject, namespaces);
        }
    }

I created a middleware called SimpleMiddleware in the solution to demonstrate one of the drawbacks of this solution and why I started searching for solution 3. The middleware simply sets the response status to 200.

The middleware is commented in the Configure() method in the Startup.cs file.

you may uncomment and check out the error

 //app.UseSimpleMiddleware();

Output

Endpoint 1: Washington Weather Staion

<WeatherForecast xmlns:WS="http://www.wausweatherStation.com/xml/namespaces/type" xmlns:Metric="http://www.wausweatherstation.com/xml/namespaces/siunit/temperature">
<Date>2020-06-02T13:50:52.5094204-04:00</Date>
<Temperature>
<Celsius>8</Celsius>
<Farenheit>46</Farenheit>
</Temperature>
<Summary>Mild</Summary>
</WeatherForecast>

Endpoint 2: Quebec Canada Weather Station

<WeatherForecast xmlns:WS="http://www.qubeccanadaweatherstation.com/xml/namespaces/type" xmlns:Metric="http://www.qubeccanadaweatherstation.com/xml/namespaces/siunit/temperature">
<Date>2020-06-02T13:56:09.5506734-04:00</Date>
<Temperature>
<Celsius>34</Celsius>
<Farenheit>93</Farenheit>
</Temperature>
<Summary>Cool</Summary>
</WeatherForecast>

Solution 3

Code

The sample code for solution is here

or https://github.com/BipinBlog/asp.net_response_manipulation

Solution : Serialize_in_action_filter.sln

Alternate ways to intercept and manipulate response in Asp.Net core- Part 1

Bipin Radhakrishnan — Sun, 07 Jun 2020 11:42:06 +0000

I'm going to make this post kind of a problem and solution post. In my pursuit to solve my problem, I stumbled upon three different solutions. I'm going to make each of these solutions a different post/ part. I will also discuss the pros and cons that I found with each of the solutions.

The Problem:

Solution 1

Using Action Filter to clear the output formatter of the MVC pipeline and adding the vendor-specific formatter

Pros and Cons of the solution

Pros:

Code is nice separated, i.e business logic is taken care of by the API, and formatting the output is achieved by the formatters.

Cons

We are directly manipulating the output formatters in the MVC pipeline.
Unable to test in my machine, but I believe this may interfere with other endpoints, I also noticed a null reference exception from this area after hosting in the cloud.

Implementation

Step 1

I created two output formatters inheriting from XmlSerializerOutputFormatter. I serialize the object to the correct format using the vendor-specific XML namespaces.

The snippet of output formatter

namespace OutputFormatter.API
{
    public class WashingtonOutputFormatter : XmlSerializerOutputFormatter
    {
        public WashingtonOutputFormatter()
        {

        }
        public WashingtonOutputFormatter(XmlWriterSettings xmlWriterSettings) : base(xmlWriterSettings)
        {

        }
        protected override void Serialize(XmlSerializer xmlSerializer, XmlWriter xmlWriter, object value)
        {
            var namespaces = new XmlSerializerNamespaces();
            namespaces.Add("WS", "http://www.wausweatherStation.com/xml/namespaces/type");
            namespaces.Add("Metric", "http://www.wausweatherstation.com/xml/namespaces/siunit/temperature");
            xmlSerializer.Serialize(xmlWriter, value, namespaces);
        }

    }
}

Step 2

Create two ActionFilterAttribute, in this case for Quebec Canada and another for Washington. These two action filters will clear the existing output filters in the MVC pipeline and add the corresponding output filter. Quebec Canada Action filter will add the Quebec Canada output formatter to the pipeline and the Washington Action filter will add only Washington output formatter.

screen shot of action filter attribute

public class WashingtonOuputFilterAttribute : ActionFilterAttribute
    {

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            var washingtonOutputFormat = new WashingtonOutputFormatter(new XmlWriterSettings()
            {
                OmitXmlDeclaration = true
            });

            var outputFormattersToRemove = new List<IOutputFormatter>()
            {
                new XmlSerializerOutputFormatter(),
                new SystemTextJsonOutputFormatter(new System.Text.Json.JsonSerializerOptions()),
                new QuebecCanadaOutputFormatter()
            };
            var commonFormatter = new FilterActionCommon();
            commonFormatter.ClearOutputFormatters(context, outputFormattersToRemove);
            commonFormatter.AddOutputFormatter(context, washingtonOutputFormat);
            base.OnActionExecuting(context);
        }
    }

Output

Endpoint 1: Washington Weather Staion

<WeatherForecast xmlns:WS="http://www.wausweatherStation.com/xml/namespaces/type" xmlns:Metric="http://www.wausweatherstation.com/xml/namespaces/siunit/temperature">
<Date>2020-06-02T13:50:52.5094204-04:00</Date>
<Temperature>
<Celsius>8</Celsius>
<Farenheit>46</Farenheit>
</Temperature>
<Summary>Mild</Summary>
</WeatherForecast>

Endpoint 2: Quebec Canada Weather Station

<WeatherForecast xmlns:WS="http://www.qubeccanadaweatherstation.com/xml/namespaces/type" xmlns:Metric="http://www.qubeccanadaweatherstation.com/xml/namespaces/siunit/temperature">
<Date>2020-06-02T13:56:09.5506734-04:00</Date>
<Temperature>
<Celsius>34</Celsius>
<Farenheit>93</Farenheit>
</Temperature>
<Summary>Cool</Summary>
</WeatherForecast>

you can see that the only difference between the two output are the namespaces.

Solution 2

Code

The sample code for this is here

or https://github.com/BipinBlog/asp.net_response_manipulation

Solution : OutputFormatters-Pipeline.sln

My learning plan 2020

Bipin Radhakrishnan — Fri, 29 May 2020 10:55:59 +0000

This is a list of things I want to learn in 2020 and why these subjects interest me. These are not in any order, so I may try to learn things based on my interest and as I time permits. I know this is a pretty extensive list, so I'm trying to achieve as much possible. I believe some I can learn as part of my work.

I want to learn Angular, this is a very popular framework and I could use this at my work too. An added advantage, the latest version of angular uses typescript and I can pick up some typescript when learning angular.
Learning React, another popular framework. I tried to learn some basics and found this very interesting. React is also used in building cross-platform apps using react native for mobile and electronjs for desktop.
I want to learn Adobe Photoshop and Adobe Lightroom because I'm also a photography enthusiast and want to be better in photo editing.
I want to learn vue.js, this is another front end framework for web design that is gaining a lot of traction.
Master SOLID principles, is fundamental for any good application architecture. I have a good understand of SOLID principles and try to follow these in my application architecture, but no always.
Learn Kubernetes, because of this industry-acclaimed container orchestration system.
Complete Harvard CS50 course, this is a great course to refresh your computer science basics and is considered to be the best.
Learn a bit of Python, python is a favorite for folks in data analysis, AI, and Machine learning. These are areas I would like to learn at some point in the future. So learning a little bit of Python will benefit me. I'm hoping I can lean this as part of the CS50 course.
I want to learn golang, I have a heard lot about golang and how this is being used increasingly more these days.
Learning Nodejs, I know a little bit of nodejs already. I worked on a personal project using nodejs, but did not get time to learn it properly and finish my project.

I created an AutoMapper in C# to copy property values automatically

Bipin Radhakrishnan — Wed, 27 May 2020 09:24:41 +0000

I was working on a project that required mapping values to complex objects when I say complex the target object was a large collection of multiple objects several levels deep. Some of the objects to which the values had to be mapped were several levels down. The task of finding the correct objects or directly assigning values to the properties of objects was tedious, especially if it had to be done over and over again. This problem led me to create the object auto mapper. During the course of this post, the target is the object you are operating on or mapping the values to and the source is the object from which the values are copied.

Auto mapper uses reflection to index all the objects on which it is operating. After the index is created, the algorithm can then identify the target object on which to operate based on the type of the source object. Once the target object is found then the algorithm sweeps through the properties of the target to identify all the properties that have a public set on them. The algorithm will now set the values of the properties.

Some of the features of my Auto mapper is

Automatically finds the first occurrence of an object type and maps them.
If there are multiple objects of the same type in the target object, you can specify the property name to map it to.
If the object already has some data in it, this will preserve the existing once and map only the new once.
If the target property is null, the auto mapper can initialize the property and map the values.
If the target property is a List or an Array[], it can initialize it.
If the property is null or if it already has values the new values get added to it.

https://github.com/rbipin/AutoMapper

5 Useful IBM DB2 Queries

Bipin Radhakrishnan — Thu, 04 Jan 2018 05:22:20 +0000

Here are some IBM DB2 queries that can be very useful.

Query to identify Stores Procedures that is using a particular table

Identify Schema used by a Stored Procedures

Identify Primary Key of a table

Identify Foreign key of a table

View used by table

Log4net rolling file log based on date and file size

Bipin Radhakrishnan — Tue, 15 Aug 2017 03:04:08 +0000

Logging is an important part of any application and a developer spends a good amount of time writing code to log. Logging is important as this helps us create a trace of all the events in the application and in turn helps in debugging, identifying and analyzing issues and bugs. Log4net is an open source framework for logging the output in an application. The application framework is released under Apache License, Version 2.0. Log4net provides multiple types of logging techniques.

What we are going to discuss today is how to configure log4net for a requirement I wanted to implement in one of my project? Requirement was to implement a rolling log system based on date and file size. i.e I wanted to implement a file logging, that would create a new log file everyday and if the file size extends a certain size it should create a new file.

To accomplish this, I used the “RollingFileAppender” for the type of appender. Let’s discuss the important parameters in the configuration.

PreserveLogFileNameExtension – This parameter indicates if the file extension of the log files should be preserved during rolling.
rollingStyle – Rolling criteria to use for log, I used Composite to roll based on date and size of the log.
datePattern – Date pattern to append to the log file name, I configured this as _MMddyyyy.
maxSizeRollBackups – Maximum number of log files to keep before deleting during rolling.
maximumFileSize – Maximum size of the log file before it is rolled to new file.
staticLogFileName – Indicates whether to always log in the same file, I set this to true.

For the component to read the parameter from the config file. We to add the following code.

XmlConfigurator.Configure();
or
[assembly: log4net.Config.XmlConfigurator(Watch=false)]

The parameters used in the configuration are given below.

<log4net>
  <appender name="RollingLogFile" type="log4net.Appender.RollingFileAppender">
    <file value="log.log" />
    <PreserveLogFileNameExtension value="true"/>
    <appendToFile value="false" />
    <rollingStyle value="Composite"/>
    <datePattern value="_MMddyyyy"/>
    <maxSizeRollBackups value="2"/>
    <maximumFileSize value="10KB"/>
    <staticLogFileName value="true" />
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
    </layout>
  </appender>
  <root>
    <appender-ref ref="RollingLogFile" />
  </root>
</log4net>

The sample code with the configuration and code used to test the rolling log is available in the below repository

Sample Code: https://github.com/rbipin/RollingLog_Log4net