BitState
I take responsibility for systems that have to work.
I understand, stabilize, improve and maintain business-critical software: from inherited systems to new products.
Situations you will probably recognize
People come to me about situations like these, not about technologies.
Failures repeat, the cause is never found
The same fault returns every few weeks. It gets patched over, but the structural cause remains.
Nobody clearly owns the system
The developers changed, there is no documentation, and every change feels risky.
Integrations held together with tape
Data travels between systems through manual exports and scripts nobody remembers writing.
Manual work eats the team’s time
People spend their days doing what software should have been doing long ago.
The system is outdated, but the business runs on it
Changing it feels dangerous, keeping it is expensive. You need a plan that does not stop daily work.
There is an idea, but no technical foundation
A new product or internal tool needs an architecture that will survive growth.
What I take responsibility for
Different tasks, one engineering practice, one accountable person.
Takeover and maintenance
Taking over existing systems
I take over a running system, document it, and answer for how it runs every day.
Problem investigation
Recurring incidents get traced to their real cause instead of being patched over.
Analysis and architecture
Technical and process analysis
A clear picture of how the system and the people around it actually work, and where time is lost.
Solution architecture
New products and larger changes designed to survive growth and change.
Improvement and development
Optimization and integrations
Slow paths, unstable connections and data flows fixed in measurable steps.
Building new solutions
Software and internal tools built to stay maintainable for years.
Understand first. Then change.
Before proposing anything, I build a real map of the system: users, data, dependencies, processes, and the places where it breaks.
Most recurring problems are structural. So I look for the cause first, not for a quick patch.
I change things in small, controlled steps so the system keeps running the whole time. The big rewrite is usually the biggest risk.
The standard I am used to
For eight years I built and maintained medical and laboratory systems: analyzer integrations, LIS and HIS solutions, sensitive data, and processes where a mistake is an incident, not an inconvenience.
That experience taught me to work with complex, critical systems. I apply the same standard of responsibility to every system I take over.
Same principles, different systems
The areas I work in most often.
E-commerce
Stores, inventory, payments and integrations with suppliers and accounting.
Business and internal systems
The tools a team works with every day: from order management to reporting.
Integrations and data flows
APIs, middleware and exchanges between systems, joined into a reliable whole.
Medical and laboratory systems
Software where accuracy and traceability are mandatory.
New products
Software from idea to a working, maintained solution.
Automation and AI: tools, not the point
Where a process repeats and eats people’s time, I automate it. I use AI when it solves a clearly defined problem.
Before automating anything, I make sure the process itself is right. Automated chaos is still chaos, just faster.
That is why automation comes at the end, not the beginning: once the system is understood and stable.
How I work
You work directly with me. From the first conversation to ongoing ownership.
Review
A conversation about the system, the problems and the goals. Where possible, I look at the code and processes up close.
Assessment and plan
What I found, what I propose to change, in what order, and what it costs. Clearly, in writing.
Implementation
Small steps, visible results, regular updates. The system stays operational.
Launch
Changes reach people in a controlled way: with checks and a safe way back.
Ongoing ownership
You are left with an engineer who knows the system. Not a ticket queue.
About me
I am Karolis, a software systems engineer based in Kaunas, Lithuania.
For eight years I have worked on systems where mistakes are expensive: medical, laboratory and business software. BitState is my personal practice: you work directly with me.
My standard is simple: the system has to work without me, but I have to be reachable when its work matters.
- Location
- Kaunas, Lithuania
- Experience
- 8+ years with business-critical systems
- Languages
- Lithuanian, English
- Working model
- Direct, no intermediaries
Frequently asked
Do you take over systems built by someone else?
Yes, that is the most common case. I start with analysis and documentation, and take over responsibility gradually, without stopping the work.
Do you only work with the medical sector?
No. Medical systems are part of my experience, but I work with e-commerce, business systems, integrations and new products. The principles are the same.
How is pricing worked out?
A fixed price for clearly scoped work, or a monthly or hourly model for ongoing ownership. Agreed before anything starts.
What happens after launch?
The system stays looked after: monitoring, updates, support and further improvements. Directly, without a new contract for every question.
Where do automation and AI come into this?
Where the process is understood and repeats: document processing, data flows, routine triage. They are tools, not the foundation.
What does the collaboration look like day to day?
A clear point of contact, regular updates, and decisions explained in plain language. You do not need to code to know what is happening.
Get in touch
Describe the system, the problem, the process or the idea. I will reply personally.
Or directly:
info@bitstate.lt
+370 660 17200