What are the differences between Pcall and Coroutine?

Pcall is a function you can use for creating your own error handler. Pcall will execute a function and will return two values: a bool value to see if the function has successfully ran without any errors, and an error message, if there was an error.

function Func1()
       print('Hi')
end

function Func2()
        PRint('Hi')
end)

local success1, message1 = pcall(Func1)
local success2, message2 = pcall(Func2)

if success1 then
       print('Successfully ran 1st func')
else
       print('Failed to run 1st func: '..message1)
end

if success2 then
       print('Successfully ran' 2nd func')
else
      print('Failed to run 2nd func: '..message2)
end

This script above will print 'Successfully ran 1st func', but will print 'Failed to run 2nd func: error here's

Coroutines are useful for multi-threading. They allow you to execute code at the same time. Coroutines have the same purpose of Spawn()

local coro1 = coroutine.wrap(function()
       for i = 1, 10 do
              print(i)
              wait(1)
       end
end)

local coro2 = coroutine.wrap(function()
       local i = 1
       repeat
            i = i+1
            print(i)
            wait(1)
       until i <= 10
end)

coro1()
coro2()

This will run the for and repeat loop at the same time.

I really don't know how you find a similarity between these

I'm not 100% sure, but pcalls return a false value if the function inside fails to execute for some reason (which allows for measures in case a crucial function fails, like saving a player's game) and coroutine allows you to run 2 functions at the same time? I don't think there's a relation between the two, and I also think coroutines are discouraged in favour of spawn().

pcall and coroutines are two completely different things.

Pcall

pcall stands for protected call and accepts one input function optionally along with the paramters to be passed into the input function. Examples:

local success = pcall(print , "Hello world!")

local success = pcall(function(num1 , num2)
    print(num1 + num2)
end , 5 , 8)

The purpose of pcall is to catch any errors that are thrown by the block of code inside the function given. Usually these errors aren't supposed to be syntax errors (for example a typo) or logic errors (your code works but it doesn't produce the expected result). pcall is typically used to catch errors that aren't in your control at all namely datastore and web api requests. pcall also returns two values. The first one indicates whether or not the function errored or not and the second value is the error message. If the function executed successfully however, the second value is the value the function would normally return. Keep in mind that if an error does get thrown, the script will continue on like normal instead of terminating the current thread hence the name protected call. Variants of pcall include xpcall and ypcall.

Coroutines

Coroutines are lua's api so to speak to threading. For a much more detailed and comprehensive guide, I recommend reading this. In a nutshell, coroutines allow you to have full control over multiple threads at once. Typically, one would use Roblox's own thread scheduler instead (wait, spawn, and delay). Using coroutines, you can yield and resume multiple threads via coroutine.resume and coroutine.yield. You can also pass values too and from a coroutine. Pcalls don't allow you to do any of this. There is way too much to cover here on the topic of coroutines in one answer let alone a brief paragraph so I'll leave it here.

Good luck!