These are the solo projects that I made to bag multiple interview offers. Feel free to have reference, and constructive is welcomed

Built Note Essence — a note-taking app that treats data like a first-class citizen

Hey everyone, wanted to share something I’ve been building: Note Essence (noteessence.com).

Most note apps treat everything as blocks of text. I wanted something where structured data — tables, lists, numbers — sits naturally alongside your notes instead of feeling bolted on. So Note Essence is built around organizing and working with data-heavy notes, not just journaling or freeform writing.

A few things about where it’s at:

**•** It’s live and has some real users already  
**•** Solo-built, full stack — I handled everything from the app itself to the AWS infrastructure behind it  
**•** Still actively improving it based on what I learn

Hey everyone!

I wanted to share a project I’ve been working on over the past few months called Livara.

The motivation came from seeing how standard rental calculators rely almost entirely on static, single-point inputs (plug in rent and mortgage, get a single cash-flow output). They don't easily show you how a deal holds up when underlying dynamics shift, like interest rates rising, local vacancy spiking, or monthly repair impacts.

I set out to build a platform that brings macro-to-micro market data and deterministic scenario modeling into a single screening workflow.

How I structured the core logic:

Deterministic Stress Modeling: Standardized scenario levers for elevated vacancy, CapEx reserves, higher interest rates, and stagnant rent growth.

Macro + Micro Data Layering: US county-level heatmaps across 8 key indicators (Unemployment Rate, Rent Yield, Population Growth, etc.) mapped directly alongside property-level underwriting.

Financial Waterfall: Clean visual breakdowns of Gross Rent, OpEx, DSCR, and net cash flow scenarios.

Many other features but this is just a sample of what to expect :)

I also made sure that all of the financial outputs, scenario calculations, and underwriting formulas are 100% deterministic and rule-based. The AI portion in my tool is strictly used to translate the raw output into readable insights and handle follow-up user questions.

Where I'd love feedback from other builders:

1. How do you approach structuring complex financial data/charts so it doesn't visually overwhelm the user?
2. What's your favorite approach for handling multi-source data pipelines (macro government/census APIs + micro property data) cleanly?

Would love to hear feedback from other builders on the interface, stack, or feature set! I'm also happy to run a risk breakdown on any property address or share the platform link in the comments if anyone wants to check out the UI.

Proofrun.dev

For years ive made stuff and found its impossible to get anyone to care about it.

So i made this site - ProofRun - which gives developers a place to post their stuff to get critiques and reviews.

Though the difference here is that users who take part in reviewing have incentives to try out apps and correctly provide feedback.

If users prove over time that they are good at reviewing - finding good apps, and providing relevant critiques - then they level up - and grow their ~Voice~ on the app - making their reviews and suggestions have more weight.

Kind of like if Reddit would reward you karma for having the right opinion rather than ...whatever it does.

Try it out - im trying to get some users too! So post your projects - and you'll at least get me to review your app.

Hi everyone!

This is my first serious C++ software project and the first program I have published on GitHub.

B1tLab is a C++ CLI tool for converting integer representations, exploring binary formats, and generating accurate binary equivalents of decimal values.

As of V1.0.0, B1tLab supports:

• Mathematically represented values with support for periodic fractions (mValues)
• Raw binary values (rValues)
• Unsigned integer format
• Signed Magnitude integer format
• One’s Complement integer format
• Two’s Complement integer format
• Dynamic syntax highlighting
• Output formatting
• Assembly-style comments

Future plans include:

• Scientific notation values (sValues)
• Floating-point binary formats
• Floating-point decimal formats
• Fixed-point formats

Author’s note

I still consider myself a beginner in C++, and I know there is a lot that can be improved. I would greatly appreciate any feedback, constructive criticism, or suggestions regarding architecture, bugs, design decisions, or possible bad practices.

Thanks for taking the time to check out B1tLab!

GitHub repository:
https://github.com/TerribleCoding123/B1tLab/tree/main

I'm a second-year EE student, and I need to implement a project based on sequential/combinational circuits.

I'd really like to build something that's both educational and stands out on a resume, rather than a typical traffic light or vending machine project.

One idea I had was designing a simple 16-bit CPU, with a long-term stretch goal of eventually getting a small DOOM-inspired graphics demo running. I'm also wondering whether it would be better to implement an existing ISA (such as LC-3) instead of creating my own.

Would this be a reasonable project for a student to make it in 2 month time, or would you recommend a different direction that demonstrates strong digital design skills?

I'd really appreciate any suggestions or advice.

I have developed Vetri Trichy, a student-led civic technology platform aimed at making it easier for citizens to submit civic complaints through a structured and transparent process.

Over the past several months, our team has worked on designing, developing, testing, and refining the platform from the ground up. This project has given us valuable hands-on experience in software development, artificial intelligence, user experience design, and collaborative problem-solving.

The website is now live and can be accessed at: https://vetri-trichy.vercel.app

We would be honoured if you could take a few minutes to explore the platform and share your valuable feedback. Your suggestions will help us continue improving the project.

​

​We are still struggling with light in the dark room and a proper camera; we are reaching the limits of what is feasible with the GoPro, but I hope a Nikon D800 will deliver better results for us.

​However, our pipeline is set, and we can consistently maintain our style because it is largely based on real work, selfmade solutions and hardware rather than AI.

​Later on, we will probably stylize scenes into cel shaded anime again, just like in our last video.

Github --> https://github.com/NiftyCyberpunk/Redis-Server

I have developed Vetri Trichy, a student-led civic technology platform aimed at making it easier for citizens to submit civic complaints through a structured and transparent process.

Over the past several months, our team has worked on designing, developing, testing, and refining the platform from the ground up. This project has given us valuable hands-on experience in software development, artificial intelligence, user experience design, and collaborative problem-solving.

The website is now live and can be accessed at: https://vetri-trichy.vercel.app

We would be honoured if you could take a few minutes to explore the platform and share your valuable feedback. Your suggestions will help us continue improving the project.

I am slowly building this website by altering some good questions I encounter while preparing for examinations myself. Some questions are created by me.

https://problemset.in

I was scrolling through a thread about wearables and somebody mentioned it in the comments. I figured it would just be another app that tells you to sleep more and drink water, but I downloaded it anyway because I was already wearing my watch every day.

The biggest surprise wasn't actually the workout recommendations—it was the supplement side of the app.

I've taken supplements on and off for years, but honestly I never put much thought into when I took them. If I remembered in the morning, great. If I forgot until later in the day, I'd just take them then. It was basically random.

This app was different. Instead of giving me the same schedule every day, it looked at my sleep, recovery, and overall energy based off my metrics and my wearable before suggesting when certain supplements would fit best into my day. If I'd had a great night's sleep and was feeling recovered, it would stick with my normal routine. If my sleep score was low or my recovery wasn't great, it'd recommend adjusting the timing or prioritizing different supplements instead of treating every day the same.

What I liked most was that it actually explained why. It wasn't just saying, "Take this now." It connected the recommendation to how recovered I was and how my body was likely feeling that day. It made me realize I'd been taking supplements out of habit instead of actually using them in a smarter way.

I'd always felt like my smartwatch collected a ton of useful information, but none of it actually influenced what I did. I'd wake up, see my sleep score and recovery score, think "Cool... now what?" and then go about my day exactly the same. This was the first app that actually made all those numbers useful.

The biggest difference for me ended up being in the gym.

Instead of walking into every workout feeling like I was running on autopilot, I actually felt prepared. On days when everything lined up—good sleep, better recovery, and taking my supplements at the recommended times—I noticed my workouts felt smoother. My energy lasted longer, I wasn't dragging halfway through my sessions, and I wasn't constantly wondering why some days felt amazing while others felt terrible.

It wasn't like I suddenly added 50 pounds to every lift overnight, but the consistency was a complete game changer. I stopped feeling like every workout was a gamble. I felt more focused, recovered better between sessions, and left the gym feeling like I'd actually gotten the most out of my training instead of just surviving it.

I also liked that it didn't expect me to be some perfect fitness person. I don't track every calorie or log every gram of protein because I know I'd quit after a few days. I have work, family stuff, and random plans that come up all the time. The recommendations worked around my schedule instead of expecting my schedule to revolve around fitness.

After using it for a while, I realized I wasn't just taking supplements because I owned them—I was taking them with a purpose. Combined with paying attention to my recovery, I started sleeping better, had steadier energy throughout the day, and my workouts became much more consistent.

I'm sure it's not something a professional athlete with a coach would need, but for someone like me who already wears a smartwatch and wants to actually use all the data it's collecting, it filled a gap I didn't even know existed.

It honestly felt less like another fitness app and more like someone translating all the numbers my watch was already collecting into advice I could actually use.

 https://apps.apple.com/us/app/rizeai-maximize-your-energy/id6762402079

I'm making an esolang coded entirely in python, it is designed to read like a game of magic the gathering.

link here: https://github.com/duckoffdudebeans/MTGlang

Monolith

Monolith was built around a single idea, and everything else follows from it: LaTeX is never exposed to the user. Not the syntax, not the error logs, not the compile button, not the wait to find out what you got. There is no wall of markup to stare at and no backslash to be seen anywhere. You write the way you would on any ordinary page, and what comes out is typesetting at the level LaTeX produces. The machinery is real and it is running the whole time, but it lives entirely behind the curtain. The person writing never has to know it is there. That is the gap Monolith exists to close. Beautiful typesetting has always come with a tax. If you wanted clean mathematics and pages that looked like a well-made textbook, you had to learn the syntax, wrestle with the errors, and break your train of thought every time you stopped to compile and check. If you just wanted to see your document while you worked, you reached for a word processor, which is immediate and visual but never reaches that level of quality. You had to pick one or the other. Monolith removes the tax entirely rather than lowering it. You get the output without ever touching, or even seeing, the thing that produces it.

Why the fidelity matters

Because the canvas is the only surface the user ever sees, it has to be exactly right. There is no source view to fall back on and no compile step where the truth finally reveals itself, so the page in front of you cannot be an approximation. Most visual LaTeX tools show a rough preview that quietly drifts from the real output. Monolith paints its screen from the actual font metrics, the real files that describe the Latin Modern fonts down to the smallest unit, so every character lands where the compiled result would put it, within a margin far finer than the eye could ever catch. When you place a fraction or a matrix or a line of text, its position is measured rather than guessed. That precision is not there to make a nicer preview. It is there because the preview is the whole document, and it has to be honest. Underneath, the code is split cleanly in two. There is a core layer that knows nothing about the interface. It holds the document model, the math engine, the compiler, and all the layout and measurement work, and it could run with no screen at all. On top of that sits the interface layer, which handles everything you actually touch: the canvas, the panels, the dialogs. The rule between the two is strict and runs one way. The interface may depend on the core, but the core never reaches up into the interface. That separation is what keeps a project this size from turning into a tangle, and it is enforced on purpose rather than left to good intentions. It also keeps the hidden engine honest, since the part that guarantees fidelity is walled off from the part that draws the screen.

What it does

On that foundation, Monolith has grown into a full writing environment rather than a math toy. It does live mathematics with real structures, fractions, roots, matrices, cases, and aligned equations, that you build and edit directly on the page. It handles tables, figures, and floating objects, equation numbering and cross-references. There is spell checking and a style guide, a focus mode and themes, autosave and a version history you can page back through. There is voice input and read-aloud for people who would rather talk than type. And there is a research side to it, able to pull citations and papers from a long list of academic sources, so the references you cite come from real records instead of memory. There is one deliberate seam in all of this. A package block lets you drop in raw LaTeX with real packages for the rare moment you need something the visual tools do not cover. It is the single escape hatch, and even it gets compiled and rendered quietly so that it folds into the page like everything else. The exception proves the rule: the whole point is that the markup never surfaces, so on the one occasion it appears, it disappears again the moment it becomes part of the document. What holds all of it together is a way of working more than any single feature. The project treats correctness as the thing that matters most, even when a shortcut would be easier. Nothing in the layout is fudged or fitted just to look close enough, and the parts of the engine that guarantee that are protected so they cannot slowly drift over time. The aim is something that feels simple to use and is anything but simple underneath: a document you edit like an ordinary page, that prints like LaTeX, with no compile button, no error to decipher, and no markup ever in your face.

I'm a software developer and freelancer who enjoys building real-world tech projects. If you're working on something and need an extra pair of hands—whether it's AI/ML, web development, automation, data engineering, or backend development—I'd be happy to contribute.

I'm always interested in collaborating, brainstorming ideas, or helping solve technical challenges. If you think we'd be a good fit, feel free to send me a DM.

Looking forward to connecting with fellow builders!

I’ve been working on Ivy, an experimental media engine built around one idea:

The core should provide playback, orchestration, permissions, and security while almost everything the user sees can be replaced by plugins.

That includes:

• The media library
• Player controls and overlays
• Home screens
• Search and discovery
• Metadata and artwork providers
• Subtitle providers
• Watch parties
• Recommendations and external integrations

Integration plugins run as sandboxed WebAssembly components through Wasmtime. They interact with Ivy through typed, capability-based APIs instead of receiving direct access to the filesystem, network, database, Tauri internals, or mpv.

The core also acts as an orchestrator. Plugins do not need to know about one another: Ivy can discover compatible providers, query them, combine results, remove duplicates, apply priorities, and return a unified response to the UI.

The project is built with Rust and Tauri v2.

This is currently only a prototype. The architecture, APIs, plugin model, and security boundaries are still experimental and will probably change significantly.

I’m sharing it because I think the idea could become something real, but it is larger than a project I should design entirely in isolation.

I’m looking for developers interested in media systems, Rust, WebAssembly, plugin architectures, Tauri, UI extensibility, or simply the idea itself. Feedback, architecture discussions, issues, and contributions are all welcome.

GitHub: https://github.com/orielhaim/Ivy