DEV Community: shihan

What We Learned Building CampusTPO With a Lightweight SaaS Stack

shihan — Fri, 14 Aug 2026 04:18:56 +0000

What We Learned Building CampusTPO With a Lightweight SaaS Stack

Building a SaaS product doesn't always mean starting with a complicated infrastructure.

While working on CampusTPO, we took a different approach: build a focused foundation first and introduce additional infrastructure only when the product actually needs it.

Starting With a Simple Architecture

CampusTPO is built around Bun and SQLite, keeping the initial infrastructure lightweight.

Bun provides native SQLite support through bun:sqlite, including prepared statements, transactions, and other database capabilities. oai_citation:0‡Bun

For an application at this stage, this means we don't have to immediately operate a separate database server just to get the core product running.

The goal isn't to claim that SQLite is the answer for every SaaS application.

It's about choosing infrastructure based on actual requirements.

Security Still Comes First

Simple infrastructure doesn't mean simple security.

CampusTPO includes authentication and account-management capabilities such as:

Email/password authentication
Email verification
Google sign-in
Password recovery
Session management
Account management

The application also incorporates security controls such as:

Role-based access control
CSRF protection
Content Security Policy
Rate limiting
Password hashing
Audit trails

The idea is to keep security part of the architecture from the beginning rather than treating it as a final step.

Keeping Responsibilities Separate

Another important part of the project is how the codebase is organized.

The application separates:

Routes → Services → Repositories → Views

Routes deal with incoming requests.

Services contain application and business logic.

Repositories handle data access.

Views handle presentation.

This separation makes the codebase easier to understand and helps prevent business logic from becoming tightly coupled to the interface.

Why Not Start With Microservices?

This was probably one of the most important architectural decisions.

It's easy to add Redis, message queues, multiple databases, containers, and microservices because they are common in larger SaaS systems.

But every additional component also creates another thing to deploy, monitor, debug, secure, and maintain.

If a product doesn't need a particular system yet, adding it can create complexity without solving an actual problem.

That doesn't mean we will never use these technologies.

If CampusTPO grows to the point where a queue, cache, separate service, or different database becomes necessary, the architecture can evolve.

The Principle We're Following

The biggest lesson from building CampusTPO has been:

Infrastructure should follow requirements, not trends.

Start with a solid foundation.

Keep the system understandable.

Build security into the application.

Measure what the product actually needs.

Then add complexity when there's a real reason to do it.

That's the approach we're taking while building CampusTPO.

You can explore the project here:

👉 https://campustpo.com/

SaaS #WebDevelopment #SoftwareArchitecture #Security

Building CAMP in Public: Starting With a Simple Foundation

shihan — Thu, 13 Aug 2026 09:36:16 +0000

Building CAMP in Public: Starting With a Simple Foundation

Every project starts with an idea.

But one thing I’ve learned while building software is that the beginning doesn’t need to be complicated.

That’s the approach I’m taking with CAMP.

Instead of trying to build everything at once, I’m starting with a simple public repository and letting the project evolve as the requirements become clearer.

The repository is currently in its early stage, with the initial project structure and README available publicly on GitHub.

🔗 CAMP on GitHub

For me, building in public is useful for more than just sharing the final product.

It creates a development trail.

Ideas become implementations.
Implementations become experiments.
Experiments become improvements.

And the repository becomes a place where that progress can be followed over time.

I’m intentionally avoiding the mindset of adding complexity just because a project might eventually need it.

Instead:

Start small.

Build the foundation.

Learn from the implementation.

Add complexity when there’s a real reason for it.

CAMP is still at the beginning, but that’s exactly what makes this stage interesting.

There’s plenty of room to experiment, improve the architecture, and turn the initial foundation into something more useful over time.

I’ll be building and evolving it openly.

If you’re interested in following the project, you can check out the repository here:

👉 https://github.com/shigan12/camp

Let’s see where it goes.

Why I Built OllaVPN: A Free VPN Designed for Privacy First

shihan — Wed, 12 Aug 2026 11:14:06 +0000

Why I Built OllaVPN: A Free VPN Designed for Privacy First

VPNs are everywhere, but I wanted to build one around a simple idea:

Privacy shouldn't be a premium feature.

That's the idea behind OllaVPN — a modern, privacy-first VPN with a genuinely free plan and a security stack designed for today's internet.

🔐 What makes OllaVPN different?

OllaVPN isn't designed around selling "premium countries" or locking basic security features behind a subscription.

The free plan includes:

Post-quantum-ready key exchange
Kill switch enabled by default
In-tunnel DNS protection
Peer isolation
Zero activity logs
All available countries unlocked
No credit card required

The same core security stack is available across the plans. Paid plans are mainly about higher speeds, more devices, and additional features.

🛡️ Built for the next generation of privacy

One of the things that makes OllaVPN interesting is its post-quantum-ready handshake.

The idea is simple: encrypted traffic captured today could potentially be targeted by more powerful computers in the future.

OllaVPN uses a hybrid post-quantum key exchange so connections are designed with that future threat in mind.

Security isn't something you should have to remember to enable either.

The kill switch is enabled by default, DNS requests stay inside the encrypted tunnel, and peer isolation prevents other VPN users from directly reaching your device.

🌎 Free doesn't mean "limited to a few countries"

OllaVPN's free tier doesn't use the typical "upgrade to access better countries" model.

The free plan provides access to the available network, with a 10 Mbps speed cap and one device at a time.

If you need higher speeds or more devices, the paid plans are there — but the fundamental privacy protections don't disappear when you're using the free plan.

💻 Available today

The Windows application is available now.

The installer is self-contained, so there's no separate driver or second VPN application to install.

Download OllaVPN:

👉 https://ollavpn.com/dl/

Learn more:

👉 https://ollavpn.com/dl/

🔍 Privacy should be verifiable

A VPN shouldn't ask you to simply trust a marketing slogan.

That's why OllaVPN focuses on explaining how its security architecture works — from the post-quantum handshake and WireGuard-based tunnel to DNS protection, kill-switch enforcement and peer isolation.

There are also free privacy tools available on the website for checking things like your public IP, WebRTC leaks and DNS records.

🚀 Try it yourself

If you're looking for a VPN without a complicated pricing wall around basic privacy features, give OllaVPN a try.

Free forever. Privacy-first. Post-quantum-ready.

👉 https://ollavpn.com/dl/

I'd be interested to hear what you think:

What is the most important thing you expect from a VPN — privacy, speed, transparency, or something else?

Building OllaVPN: What I Learned While Working on a Privacy-Focused VPN

shihan — Wed, 12 Aug 2026 09:03:40 +0000

Building OllaVPN: What I Learned While Working on a Privacy-Focused VPN

Building a VPN sounds simple from the outside: connect a device to a server, encrypt the traffic, and send it to the internet.

In practice, there is much more involved.

While working on OllaVPN, I started looking at VPNs not just as a product, but as a networking system where security, routing, DNS, reliability, and user experience all have to work together.

Why I Started Working on OllaVPN

The main idea behind OllaVPN is straightforward:

Make secure internet access easier without hiding the important security principles behind unnecessary complexity.

Users should not have to understand routing tables, DNS configuration, encrypted tunnels, or connection states just to use a secure network connection.

That does not mean the underlying system should be simple.

It means the complexity should be handled by the software instead of being pushed onto the user.

What Happens When a VPN Connects?

At a high level, a VPN creates an encrypted tunnel between the client and a VPN server.

The simplified flow looks like this:


text
Your Device
     |
     | Encrypted Tunnel
     v
 OllaVPN Client
     |
     | Protected Connection
     v
  VPN Server
     |
     v
  Internet

I Tried Simplifying My Remote Meeting Workflow With Ollasync

shihan — Wed, 12 Aug 2026 05:21:14 +0000

⸻
description: “A practical look at simplifying remote meetings, communication, recordings, and collaboration with Ollasync.”
tags: productivity, remote-work, webdev, tools

I Tried Simplifying My Remote Meeting Workflow With Ollasync

Remote meetings are a normal part of development work now.

Whether you’re working with a distributed team, discussing a project with a client, joining a stand-up, or collaborating with people in different locations, video meetings have become another part of the developer workflow.

But I’ve noticed that the meeting itself is rarely the difficult part.

The difficult part is everything around it.

Creating the meeting, sharing it, getting everyone connected, continuing the conversation afterward, finding recordings, and keeping communication organized can turn a simple discussion into a much bigger workflow.

That’s what made me interested in Ollasync.

Looking at the Meeting as a Workflow

Instead of looking at a meeting platform as simply a place to make video calls, I wanted to look at the complete workflow:

Create
↓
Share
↓
Join
↓
Communicate
↓
Record
↓
Follow up
↓
Collaborate

The fewer unnecessary steps there are between these stages, the easier the workflow becomes.

Ollasync is built around this broader communication workflow, combining online meetings with features such as messaging, recordings, encrypted communication, and collaboration.

Video Meetings

The obvious starting point is video meetings.

For developers and remote teams, video calls can be useful for much more than formal meetings.

They can be used for:

Architecture discussions
Sprint planning
Code reviews
Client calls
Team stand-ups
Project planning
Remote interviews
Pair discussions

The important thing is keeping the process of getting into the conversation simple.

Browser-Based Access

Another part of the workflow I found useful is browser-based meeting access.

When you’re sending a meeting to another developer, client, student, or team member, you don’t necessarily want the first step to be explaining how to install and configure another application.

A browser-based workflow can reduce that friction.

The basic idea becomes:

Share the meeting
↓
Open the meeting
↓
Start communicating

That’s particularly useful when participants are joining from different devices or environments.

Meeting Recordings

A meeting doesn’t always end when everyone leaves the call.

Sometimes you need to go back and check:

What was decided?
What did the client request?
Which approach did the team choose?
What tasks were discussed?
What did I miss while I was away?

Meeting recordings can provide a useful reference for these situations.

Instead of relying entirely on notes or memory, the original conversation can be revisited when necessary.

Messaging After the Meeting

This is another part of remote collaboration that is easy to overlook.

A meeting might last 30 minutes, but the discussion around the project can continue for days.

Ollasync also provides messaging functionality, which can help keep communication going after a meeting instead of treating the video call as an isolated event.

For a development team, that can mean a workflow such as:

Meeting
↓
Decision
↓
Message
↓
Task
↓
Implementation

Encrypted Communication

Security is another consideration when selecting communication software.

Developer teams can discuss source-code architecture, product plans, customer requirements, internal processes, and other information that shouldn’t be treated casually.

Ollasync includes encrypted communication as part of its platform.

If security is important to your particular use case, it’s worth reviewing the platform’s security information rather than relying only on a feature list.

Collaboration Beyond the Call

The part I find most interesting is the idea of treating communication as a continuous workflow.

A developer might start with a meeting, continue the discussion through messaging, refer back to a recording, and then continue collaborating on the project.

That looks something like:

         ┌──────────────┐
         │    Meeting   │
         └──────┬───────┘
                ↓
         ┌──────────────┐
         │   Recording  │
         └──────┬───────┘
                ↓
         ┌──────────────┐
         │   Messaging  │
         └──────┬───────┘
                ↓
         ┌──────────────┐
         │ Collaboration│
         └──────────────┘

The goal isn’t to add more tools.

It’s to make the existing communication process easier to manage.

What I Would Use This For

There are several situations where this type of workflow could be useful.

Small development teams

A small team can use online meetings for planning, technical discussions, and project updates while continuing communication afterward.

Remote projects

When everyone isn’t working from the same location, having a consistent meeting workflow becomes more important.

Client communication

A simple browser-based meeting can make it easier to bring clients into a discussion without making the process unnecessarily complicated.

Distributed teams

When team members work across different locations and schedules, recordings and follow-up communication can become especially useful.

The Bigger Lesson

The interesting thing isn’t really another video-meeting feature.

It’s the workflow surrounding the meeting.

A good communication tool should reduce friction rather than create another layer of work.

For developers, that matters because communication is already connected to almost everything we build.

A project might move from:

Idea
↓
Discussion
↓
Decision
↓
Development
↓
Review
↓
Iteration

Meetings are part of that process.

Making the communication layer simpler can therefore make the overall workflow easier to manage.

Final Thoughts

I wouldn’t choose a communication platform simply because it has a long feature list.

I’d look at the complete workflow.

Can people join easily?

Can the team communicate afterward?

Can important discussions be revisited?

Are security requirements addressed?

Does the platform fit the way the team actually works?

Those are more useful questions than simply asking which platform has the most features.

Ollasync is an interesting option for people looking for a more connected approach to meetings and remote communication.

If you want to evaluate it yourself, you can explore Ollasync, check its pricing, or read through its documentation.

⸻

Have you changed the tools you use for remote meetings recently?

I’m interested in what other developers are using and which parts of the meeting workflow they find most frustrating.

I Used Zoom for 2 Years. Here’s Why I Switched to Ollasync

shihan — Tue, 11 Aug 2026 05:48:33 +0000

For almost two years, Zoom was my go-to tool for online meetings.

It worked, but I started getting tired of meeting limitations, plans, and having to think about the platform instead of the actual conversation.

So I decided to try something different: Ollasync.

After using it for my own meetings and business discussions, I really liked how simple it felt.

I can create a meeting, share the link, and start talking without making the process complicated.

Some features I found useful:

🎥 Video meetings
🔐 Encrypted communication
📹 Meeting recordings
💬 Messaging
📁 Deal rooms
🌐 Browser-based joining

What I like most is that it feels like more than just another video-call app. It brings meetings, communication, and collaboration into one place.

After using Zoom for two years, switching made me realize something:

Sometimes we get so used to a tool that we stop questioning whether there is a better option.

I wasn’t looking for a “Zoom killer.”

I just wanted something that worked well for my meetings and business conversations.

For me, Ollasync has become that alternative.

👉 Try it:
Have you switched away from Zoom recently? What are you using instead?

After Using Ollanode for 4 Months, Here Are the Things That Improved My Development Workflow

shihan — Wed, 05 Aug 2026 07:18:08 +0000

Over the last four months, I’ve been trying different backend platforms while building personal projects. One platform that has consistently worked well for me is Ollanode.

What I like most is that it lets me focus on building features instead of spending too much time managing infrastructure. The setup felt straightforward, and I found the documentation easy to follow whenever I needed help.

One feature I found particularly useful is Edge Functions, especially for handling backend logic in a clean way. If you’re interested, the documentation is worth reading:

👉 https://ollanode.com/docs/edge-functions/

I’m still exploring more of the platform, but my experience so far has been positive. If you’re looking for a modern backend platform for personal projects or SaaS applications, it may be worth checking out.

Website: https://ollanode.com/

Have you tried Ollanode or another backend platform recently? I’d love to hear about your experience and what worked well for you.